Comment se moquer des ressources Pulumi dans les tests unitaires Go ?

Contenu de la question

J'ai une fonction qui prend les entrées de la ressource pulumi aws openidconnectprovider et crée un rôle iam et attache une stratégie de rôle d'assuré qui contient les informations de ce fournisseur oidc.

Question : J'essaie d'écrire un test pour cette fonction et de me moquer du fournisseur oidc en entrée de l'appel de fonction. Je n'arrive pas à comprendre comment simuler cela correctement pour que le résultat du test montre ce que j'attends. Actuellement, il semble que les données simulées ne sortent pas comme prévu.

On dirait que je n'utilise pas correctement le mocking, mais j'abandonne l'exemple ici

Plus de documentation ici

package mypkg

import (
   "github.com/pulumi/pulumi-aws/sdk/v5/go/aws/iam"
   "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func createmycustomrole(ctx *pulumi.context, name string, oidcprovider *iam.openidconnectprovider, opts ...pulumi.resourceoption) (*iam.role, error) {
    role := &iam.role{}

    componenturn := fmt.sprintf("%s-custom-role", name)

    err := ctx.registercomponentresource("pkg:aws:mycustomrole", componenturn, role, opts...)
    if err != nil {
        return nil, err
    }

    url := oidc.url.applyt(func(s string) string {
        return fmt.sprint(strings.replaceall(s, "https://", ""), ":sub")
    }).(pulumi.stringoutput)

    assumerolepolicy := pulumi.sprintf(`{
            "version": "2012-10-17",
            "statement": [{
                "effect": "allow",
                "principal": { "federated": "%s" },
                "action": "sts:assumerolewithwebidentity",
                "condition": {
                    "stringequals": {
                        "%s": [
                            "system:serviceaccount:kube-system:*",
                            "system:serviceaccount:kube-system:cluster-autoscaler"
                        ]
                    }
                }
            }]
        }`, oidcprovider.arn, url)

    roleurn := fmt.sprintf("%s-custom-role", name)

    role, err = iam.newrole(ctx, roleurn, &iam.roleargs{
            name:             pulumi.string(roleurn),
            description:      pulumi.string("create custom role"),
            assumerolepolicy: assumerolepolicy,
            tags:             pulumi.tostringmap(map[string]string{"project": "test"}),
        })
    if err != nil {
        return nil, err
    }

    return role, nil
}

package mypkg

import (
    "sync"
    "testing"

    "github.com/pulumi/pulumi-aws/sdk/v5/go/aws/iam"
    "github.com/pulumi/pulumi/sdk/v3/go/common/resource"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    "github.com/stretchr/testify/assert"
)

type mocks int

func (mocks) newresource(args pulumi.mockresourceargs) (string, resource.propertymap, error) {
    return args.name + "_id", args.inputs, nil
}

func (mocks) call(args pulumi.mockcallargs) (resource.propertymap, error) {
    outputs := map[string]interface{}{}
    if args.token == "aws:iam/getopenidconnectprovider:getopenidconnectprovider" {
        outputs["arn"] = "arn:aws:iam::123:oidc-provider/oidc.eks.us-west-2.amazonaws.com/id/abc"
        outputs["id"] = "abc"
        outputs["url"] = "https://someurl"
    }
    return resource.newpropertymapfrommap(outputs), nil
}

func testcreatemycustomrole(t *testing.t) {
    err := pulumi.runerr(func(ctx *pulumi.context) error {

        // gets the mocked oidc provider to use as input for the createdefaultautoscalerrole
        oidc, err := iam.getopenidconnectprovider(ctx, "get-test-oidc-provider", pulumi.id("abc"), &iam.openidconnectproviderstate{})
        assert.noerror(t, err)

        infra, err := createmycustomrole(ctx, "role1", oidc})
        assert.noerror(t, err)

        var wg sync.waitgroup
        wg.add(1)

        // check 1: assume role policy is formatted correctly
        pulumi.all(infra.urn(), infra.assumerolepolicy).applyt(func(all []interface{}) error {
            urn := all[0].(pulumi.urn)
            assumerolepolicy := all[1].(string)

            assert.equal(t, `{
            "version": "2012-10-17",
            "statement": [{
                "effect": "allow",
                "principal": { "federated": "arn:aws:iam::123:oidc-provider/oidc.eks.us-west-2.amazonaws.com/id/abc" },
                "action": "sts:assumerolewithwebidentity",
                "condition": {
                    "stringequals": {
                        "someurl:sub": [
                            "system:serviceaccount:kube-system:*",
                            "system:serviceaccount:kube-system:cluster-autoscaler"
                        ]
                    }
                }
            }]
        }`, assumerolepolicy)

            wg.done()
            return nil
        })

        wg.wait()
        return nil
    }, pulumi.withmocks("project", "stack", mocks(0)))
    assert.noerror(t, err)
}

output

diff:
                        --- expected
                        +++ actual
                        @@ -4,3 +4,3 @@
                                        "effect": "allow",
                        -               "principal": { "federated": "arn:aws:iam::123:oidc-provider/oidc.eks.us-west-2.amazonaws.com/id/abc" },
                        +               "principal": { "federated": "" },
                                        "action": "sts:assumerolewithwebidentity",
                        @@ -8,3 +8,3 @@
                                            "stringequals": {
                        -                       "someurl:sub": [
                        +                       ":sub": [
                                                    "system:serviceaccount:kube-system:*",
        test:           testcreatemycustomrole

Bonne réponse

Il s'avère que j'ai mal utilisé newresource.

Lorsque getopenidconnectprovider est appelé dans une fonction de test, il lit la ressource et crée une nouvelle sortie de ressource, déclenchant un appel à mocks.newresource

Le correctif consiste à utiliser une sortie fictive pour définir une instruction if dans l'appel de fonction newresource pour le type de ressource renvoyé par getopenidconnectprovider openidconnectprovider.

func (mocks) newresource(args pulumi.mockresourceargs) (string, resource.propertymap, error) {
    pulumi.printf(args.typetoken)
    outputs := args.inputs.mappable()
    if args.typetoken == "aws:iam/openidconnectprovider:openidconnectprovider" {
        outputs["arn"] = "arn:aws:iam::123:oidc-provider/oidc.eks.us-west-2.amazonaws.com/id/abc"
        outputs["id"] = "abc"
        outputs["url"] = "https://someurl"
    }
    return args.name + "_id", resource.newpropertymapfrommap(outputs), nil
}

func (mocks) call(args pulumi.mockcallargs) (resource.propertymap, error) {
    outputs := map[string]interface{}{}
    return resource.newpropertymapfrommap(outputs), nil
}

L'extrait de code ci-dessous est ce que j'ai modifié assert afin qu'il ne montre pas la différence maintenant par rapport aux modifications apportées à newresource ci-dessus

Diff:
                            --- Expected
                             Actual
                            @@ -8,3 +8,3 @@
                                                "StringEquals": {
                            -                       "b:sub": [
                            +                       "someurl:sub": [
                                                        "system:serviceaccount:kube-system:*",

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!