terraform/internal/stacks/stackruntime/testing/resource.go

// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1

package testing

import (
	"fmt"

	"github.com/zclconf/go-cty/cty"

	"github.com/hashicorp/terraform/internal/providers"
	"github.com/hashicorp/terraform/internal/tfdiags"
)

// resource is an interface that represents a resource that can be managed by
// the mock provider defined in this package.
type resource interface {
	// Read reads the current state of the resource from the store.
	Read(request providers.ReadResourceRequest, store *ResourceStore) providers.ReadResourceResponse

	// Plan plans the resource for creation.
	Plan(request providers.PlanResourceChangeRequest, store *ResourceStore) providers.PlanResourceChangeResponse

	// Apply applies the planned changes to the resource.
	Apply(request providers.ApplyResourceChangeRequest, store *ResourceStore) providers.ApplyResourceChangeResponse
}

func getResource(name string) resource {
	switch name {
	case "testing_resource":
		return &testingResource{}
	case "testing_deferred_resource":
		return &deferredResource{}
	case "testing_failed_resource":
		return &failedResource{}
	case "testing_blocked_resource":
		return &blockedResource{}
	case "testing_write_only_resource":
		return &writeOnlyResource{}
	case "testing_resource_with_identity":
		return &testingResourceWithIdentity{}
	default:
		panic("unknown resource: " + name)
	}
}

var (
	_ resource = (*testingResource)(nil)
	_ resource = (*deferredResource)(nil)
	_ resource = (*failedResource)(nil)
	_ resource = (*blockedResource)(nil)
	_ resource = (*writeOnlyResource)(nil)
	_ resource = (*testingResourceWithIdentity)(nil)
)

// testingResource is a simple resource that can be managed by the mock provider
// defined in this package.
type testingResource struct{}

func (t *testingResource) Read(request providers.ReadResourceRequest, store *ResourceStore) (response providers.ReadResourceResponse) {
	id := request.PriorState.GetAttr("id").AsString()
	var exists bool
	response.NewState, exists = store.Get(id)
	if !exists {
		response.NewState = cty.NullVal(TestingResourceSchema.Body.ImpliedType())
	}
	return
}

func (t *testingResource) Plan(request providers.PlanResourceChangeRequest, store *ResourceStore) (response providers.PlanResourceChangeResponse) {
	if request.ProposedNewState.IsNull() {
		response.PlannedState = request.ProposedNewState
		return
	}

	response.PlannedState = planEnsureId(request.ProposedNewState)
	replace, err := validateId(response.PlannedState, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "testingResource error", err.Error()))
		return
	}
	if replace {
		response.RequiresReplace = []cty.Path{cty.GetAttrPath("id")}
	}
	return
}

func (t *testingResource) Apply(request providers.ApplyResourceChangeRequest, store *ResourceStore) (response providers.ApplyResourceChangeResponse) {
	if request.PlannedState.IsNull() {
		store.Delete(request.PriorState.GetAttr("id").AsString())
		response.NewState = request.PlannedState
		return
	}

	value := applyEnsureId(request.PlannedState)
	replace, err := validateId(value, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "testingResource error", err.Error()))
		return
	}
	response.NewState = value

	if replace {
		store.Delete(request.PriorState.GetAttr("id").AsString())
	}
	store.Set(response.NewState.GetAttr("id").AsString(), response.NewState)
	return
}

// deferredResource is a resource that can defer itself based on the provided
// configuration.
type deferredResource struct{}

func (d *deferredResource) Read(request providers.ReadResourceRequest, store *ResourceStore) (response providers.ReadResourceResponse) {
	id := request.PriorState.GetAttr("id").AsString()
	var exists bool
	response.NewState, exists = store.Get(id)
	if !exists {
		response.NewState = cty.NullVal(DeferredResourceSchema.Body.ImpliedType())
	}
	return
}

func (d *deferredResource) Plan(request providers.PlanResourceChangeRequest, store *ResourceStore) (response providers.PlanResourceChangeResponse) {
	if request.ProposedNewState.IsNull() {
		if deferred := request.PriorState.GetAttr("deferred"); !deferred.IsNull() && deferred.IsKnown() && deferred.True() {
			response.Deferred = &providers.Deferred{
				Reason: providers.DeferredReasonResourceConfigUnknown,
			}
		}
		response.PlannedState = request.ProposedNewState
		return
	}

	response.PlannedState = planEnsureId(request.ProposedNewState)
	replace, err := validateId(response.PlannedState, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "deferredResource error", err.Error()))
		return
	}
	if deferred := response.PlannedState.GetAttr("deferred"); !deferred.IsNull() && deferred.IsKnown() && deferred.True() {
		response.Deferred = &providers.Deferred{
			Reason: providers.DeferredReasonResourceConfigUnknown,
		}
	}
	if replace {
		response.RequiresReplace = []cty.Path{cty.GetAttrPath("id")}
	}
	return
}

func (d *deferredResource) Apply(request providers.ApplyResourceChangeRequest, store *ResourceStore) (response providers.ApplyResourceChangeResponse) {
	if request.PlannedState.IsNull() {
		store.Delete(request.PriorState.GetAttr("id").AsString())
		response.NewState = request.PlannedState
		return
	}

	value := applyEnsureId(request.PlannedState)
	replace, err := validateId(value, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "deferredResource error", err.Error()))
		return
	}
	response.NewState = value

	if replace {
		store.Delete(request.PriorState.GetAttr("id").AsString())
	}
	store.Set(response.NewState.GetAttr("id").AsString(), response.NewState)
	return
}

// failedResource is a resource that can be set to fail during Plan or Apply.
type failedResource struct{}

func (f *failedResource) Read(request providers.ReadResourceRequest, store *ResourceStore) (response providers.ReadResourceResponse) {
	id := request.PriorState.GetAttr("id").AsString()
	var exists bool
	response.NewState, exists = store.Get(id)
	if !exists {
		response.NewState = cty.NullVal(FailedResourceSchema.Body.ImpliedType())
	}
	return
}

func (f *failedResource) Plan(request providers.PlanResourceChangeRequest, store *ResourceStore) (response providers.PlanResourceChangeResponse) {
	if request.ProposedNewState.IsNull() {
		response.PlannedState = request.ProposedNewState
		if attr := request.PriorState.GetAttr("fail_plan"); !attr.IsNull() && attr.IsKnown() && attr.True() {
			response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "failedResource error", "failed during plan"))
			return
		}
		return
	}

	response.PlannedState = planEnsureId(request.ProposedNewState)
	replace, err := validateId(response.PlannedState, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "failedResource error", err.Error()))
		return
	}

	setUnknown(response.PlannedState, "fail_apply")
	setUnknown(response.PlannedState, "fail_plan")

	if attr := response.PlannedState.GetAttr("fail_plan"); !attr.IsNull() && attr.IsKnown() && attr.True() {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "failedResource error", "failed during plan"))
	}
	if replace {
		response.RequiresReplace = []cty.Path{cty.GetAttrPath("id")}
	}

	return
}

func (f *failedResource) Apply(request providers.ApplyResourceChangeRequest, store *ResourceStore) (response providers.ApplyResourceChangeResponse) {
	if request.PlannedState.IsNull() {
		if attr := request.PriorState.GetAttr("fail_apply"); !attr.IsNull() && attr.IsKnown() && attr.True() {
			response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "failedResource error", "failed during apply"))
			return
		}
		response.NewState = request.PlannedState
		store.Delete(request.PriorState.GetAttr("id").AsString())
		return
	}

	value := applyEnsureId(request.PlannedState)
	replace, err := validateId(value, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "testingResource error", err.Error()))
		return
	}

	setKnown(value, "fail_apply", cty.False)
	setKnown(value, "fail_plan", cty.False)

	if attr := value.GetAttr("fail_apply"); !attr.IsNull() && attr.IsKnown() && attr.True() {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "failedResource error", "failed during apply"))
		return
	}
	response.NewState = value

	if replace {
		store.Delete(request.PriorState.GetAttr("id").AsString())
	}
	store.Set(response.NewState.GetAttr("id").AsString(), response.NewState)
	return
}

// blockedResource is a resource that accepts a list of required resource ids
// and will fail to apply if those resources don't exist. They will also fail to
// destroy if the resources do not exist - this ensures they have to be created
// and destroyed in the correct order.
type blockedResource struct{}

func (b *blockedResource) Read(request providers.ReadResourceRequest, store *ResourceStore) (response providers.ReadResourceResponse) {
	id := request.PriorState.GetAttr("id").AsString()
	var exists bool
	response.NewState, exists = store.Get(id)
	if !exists {
		response.NewState = cty.NullVal(DeferredResourceSchema.Body.ImpliedType())
	}
	return
}

func (b *blockedResource) Plan(request providers.PlanResourceChangeRequest, store *ResourceStore) (response providers.PlanResourceChangeResponse) {
	if request.ProposedNewState.IsNull() {
		response.PlannedState = request.ProposedNewState
		return
	}

	response.PlannedState = planEnsureId(request.ProposedNewState)
	replace, err := validateId(response.PlannedState, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "testingResource error", err.Error()))
		return
	}
	if replace {
		response.RequiresReplace = []cty.Path{cty.GetAttrPath("id")}
	}
	return
}

func (b *blockedResource) Apply(request providers.ApplyResourceChangeRequest, store *ResourceStore) (response providers.ApplyResourceChangeResponse) {
	if request.PlannedState.IsNull() {
		if required := request.PriorState.GetAttr("required_resources"); !required.IsNull() && required.IsKnown() {
			for _, id := range required.AsValueSlice() {
				if _, exists := store.Get(id.AsString()); !exists {
					response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "blockedResource error", fmt.Sprintf("required resource %q does not exists, so can't destroy self", id.AsString())))
					return
				}
			}
		}

		store.Delete(request.PriorState.GetAttr("id").AsString())
		response.NewState = request.PlannedState
		return
	}

	value := applyEnsureId(request.PlannedState)
	replace, err := validateId(value, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "testingResource error", err.Error()))
		return
	}

	if required := value.GetAttr("required_resources"); !required.IsNull() && required.IsKnown() {
		for _, id := range required.AsValueSlice() {
			if _, exists := store.Get(id.AsString()); !exists {
				response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "blockedResource error", fmt.Sprintf("required resource %q does not exist, so can't apply self", id.AsString())))
				return
			}
		}
	}
	response.NewState = value

	if replace {
		store.Delete(request.PriorState.GetAttr("id").AsString())
	}
	store.Set(response.NewState.GetAttr("id").AsString(), response.NewState)
	return
}

// writeOnlyResource is the same as testingResource but it includes an extra
// write-only attribute.
type writeOnlyResource struct{}

func (w *writeOnlyResource) Read(request providers.ReadResourceRequest, store *ResourceStore) (response providers.ReadResourceResponse) {
	id := request.PriorState.GetAttr("id").AsString()
	var exists bool
	response.NewState, exists = store.Get(id)
	if !exists {
		response.NewState = cty.NullVal(WriteOnlyResourceSchema.Body.ImpliedType())
	}
	return
}

func (w *writeOnlyResource) Plan(request providers.PlanResourceChangeRequest, store *ResourceStore) (response providers.PlanResourceChangeResponse) {
	if request.ProposedNewState.IsNull() {
		response.PlannedState = request.ProposedNewState
		return
	}

	response.PlannedState = setNull(planEnsureId(request.ProposedNewState), "write_only")
	replace, err := validateId(response.PlannedState, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "testingResource error", err.Error()))
		return
	}
	if replace {
		response.RequiresReplace = []cty.Path{cty.GetAttrPath("id")}
	}
	return
}

func (w *writeOnlyResource) Apply(request providers.ApplyResourceChangeRequest, store *ResourceStore) (response providers.ApplyResourceChangeResponse) {
	if request.PlannedState.IsNull() {
		store.Delete(request.PriorState.GetAttr("id").AsString())
		response.NewState = request.PlannedState
		return
	}

	value := applyEnsureId(request.PlannedState)
	replace, err := validateId(value, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "testingResource error", err.Error()))
		return
	}
	response.NewState = value

	if replace {
		store.Delete(request.PriorState.GetAttr("id").AsString())
	}
	store.Set(response.NewState.GetAttr("id").AsString(), response.NewState)
	return
}

// testingResourceWithIdentity is the same as testingResource but it returns an identity.
type testingResourceWithIdentity struct{}

func (t *testingResourceWithIdentity) Read(request providers.ReadResourceRequest, store *ResourceStore) (response providers.ReadResourceResponse) {
	id := request.PriorState.GetAttr("id").AsString()
	var exists bool
	response.NewState, exists = store.Get(id)
	if !exists {
		response.NewState = cty.NullVal(TestingResourceSchema.Body.ImpliedType())
		response.Identity = cty.UnknownVal(TestingResourceWithIdentitySchema.Identity.ImpliedType())
	} else {
		response.Identity = cty.StringVal("id:" + id)
	}
	return
}

func (t *testingResourceWithIdentity) Plan(request providers.PlanResourceChangeRequest, store *ResourceStore) (response providers.PlanResourceChangeResponse) {
	if request.ProposedNewState.IsNull() {
		response.PlannedState = request.ProposedNewState
		return
	}

	response.PlannedState = planEnsureId(request.ProposedNewState)
	response.PlannedIdentity = cty.ObjectVal(map[string]cty.Value{
		"id": cty.StringVal("id:" + response.PlannedState.GetAttr("id").AsString()),
	})
	replace, err := validateId(response.PlannedState, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "testingResourceWithIdentity error", err.Error()))
		return
	}
	if replace {
		response.RequiresReplace = []cty.Path{cty.GetAttrPath("id")}
	}
	return
}

func (t *testingResourceWithIdentity) Apply(request providers.ApplyResourceChangeRequest, store *ResourceStore) (response providers.ApplyResourceChangeResponse) {
	if request.PlannedState.IsNull() {
		store.Delete(request.PriorState.GetAttr("id").AsString())
		response.NewState = request.PlannedState
		return
	}

	value := applyEnsureId(request.PlannedState)
	replace, err := validateId(value, request.PriorState, store)
	if err != nil {
		response.Diagnostics = append(response.Diagnostics, tfdiags.Sourceless(tfdiags.Error, "testingResourceWithIdentity error", err.Error()))
		return
	}
	response.NewState = value
	response.NewIdentity = request.PlannedIdentity

	if replace {
		store.Delete(request.PriorState.GetAttr("id").AsString())
	}
	store.Set(response.NewState.GetAttr("id").AsString(), response.NewState)
	return
}

func validateId(target cty.Value, prior cty.Value, store *ResourceStore) (bool, error) {
	if prior.IsNull() {
		// Then we're creating a resource, we want to make sure we're not
		// creating a resource with an existing ID.
		if id := target.GetAttr("id"); id.IsKnown() {
			if _, exists := store.Get(id.AsString()); exists {
				return false, fmt.Errorf("resource with id %q already exists", id.AsString())
			}
		}

		return false, nil
	}

	if attr := target.GetAttr("id"); !attr.IsKnown() {
		// Then the attribute has been set to unknown, which means we're
		// potentially changing the id.
		return true, nil
	}

	// Now, we know that the ID is known in both the prior and target states.
	if result := prior.GetAttr("id").Equals(target.GetAttr("id")); result.False() {
		// Then the ID value is changing, so we need to delete the old ID
		// and create the new one.
		return true, nil
	}

	return false, nil
}

func planEnsureId(value cty.Value) cty.Value {
	return setUnknown(value, "id")
}

func applyEnsureId(value cty.Value) cty.Value {
	return setKnown(value, "id", cty.StringVal(mustGenerateUUID()))
}

func setUnknown(value cty.Value, attr string) cty.Value {
	if v := value.GetAttr(attr); v.IsNull() {
		vals := value.AsValueMap()
		vals[attr] = cty.UnknownVal(cty.String)
		return cty.ObjectVal(vals)
	}
	return value
}

func setKnown(value cty.Value, attr string, attrValue cty.Value) cty.Value {
	if v := value.GetAttr(attr); !v.IsKnown() {
		vals := value.AsValueMap()
		vals[attr] = attrValue
		return cty.ObjectVal(vals)
	}
	return value
}

func setNull(value cty.Value, attr string) cty.Value {
	if v := value.GetAttr(attr); !v.IsKnown() {
		vals := value.AsValueMap()
		vals[attr] = cty.NullVal(v.Type())
		return cty.ObjectVal(vals)
	}
	return value
}