Wie kann man Pulumi-Ressourcen in Go-Unit-Tests verspotten?

Frageninhalt

Ich habe eine Funktion, die Eingaben von der Pulumi-Ressource „aws openidconnectprovider“ entgegennimmt, eine IAM-Rolle erstellt und eine „Assumerolepolicy“ anhängt, die die Informationen von diesem OIDC-Anbieter enthält.

Frage: Ich versuche, einen Test für diese Funktion zu schreiben und den OIDC-Anbieter als Eingabe für den Funktionsaufruf zu simulieren. Ich kann nicht herausfinden, wie ich das richtig simulieren kann, damit die Testausgabe das zeigt, was ich erwarte. Derzeit sieht es so aus, als würden die simulierten Daten nicht so ausgegeben, wie ich es erwartet habe.

Sieht so aus, als würde ich Spott nicht richtig verwenden, aber ich verzichte hier auf das Beispiel

Weitere Dokumentation hier

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

Richtige Antwort

Es stellte sich heraus, dass ich newresource falsch verwendet habe.

Wenn getopenidconnectprovider in einer Testfunktion aufgerufen wird, liest es die Ressource und erstellt eine neue Ressourcenausgabe, wodurch ein Aufruf von mocks.newresource

ausgelöst wird

Die Lösung besteht darin, eine Scheinausgabe zu verwenden, um eine if-Anweisung im newresource-Funktionsaufruf für den von getopenidconnectprovider zurückgegebenen Ressourcentyp zu definieren 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
}

Das folgende Code-Snippet habe ich geändert assert, sodass es jetzt nicht den Unterschied zu den oben an newresource vorgenommenen Änderungen zeigt

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

Das obige ist der detaillierte Inhalt vonWie kann man Pulumi-Ressourcen in Go-Unit-Tests verspotten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!