add tests

Author: dsa0x

internal/command/test_allowrace_test.go

@@ -0,0 +1,110 @@
+//go:build !race
+// +build !race
+
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package command
+
+import (
+	"encoding/json"
+	"path"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/hashicorp/cli"
+	testing_command "github.com/hashicorp/terraform/internal/command/testing"
+	"github.com/hashicorp/terraform/internal/command/views"
+	"github.com/hashicorp/terraform/internal/terminal"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// The test contains a data race due to the disabling of the provider lock.
+// The provider lock was disabled, so that we can measure the true duration of the
+// test operation. Without disabling the provider lock, runs may block each other
+// when working with the provider, which does not happen by default in the real-world.
+func TestTest_ParallelJSON(t *testing.T) {
+	td := t.TempDir()
+	testCopyDir(t, testFixturePath(path.Join("test", "parallel")), td)
+	defer testChdir(t, td)()
+
+	provider := testing_command.NewProvider(&testing_command.ResourceStore{
+		Data:   make(map[string]cty.Value),
+		Nolock: true,
+	})
+	providerSource, close := newMockProviderSource(t, map[string][]string{
+		"test": {"1.0.0"},
+	})
+	defer close()
+
+	streams, done := terminal.StreamsForTesting(t)
+	view := views.NewView(streams)
+	ui := new(cli.MockUi)
+
+	meta := Meta{
+		testingOverrides: metaOverridesForProvider(provider.Provider),
+		Ui:               ui,
+		View:             view,
+		Streams:          streams,
+		ProviderSource:   providerSource,
+	}
+
+	init := &InitCommand{Meta: meta}
+	if code := init.Run(nil); code != 0 {
+		output := done(t)
+		t.Fatalf("expected status code %d but got %d: %s", 9, code, output.All())
+	}
+
+	c := &TestCommand{Meta: meta}
+	c.Run([]string{"-json", "-no-color"})
+	output := done(t).All()
+
+	if !strings.Contains(output, "40 passed, 0 failed") {
+		t.Errorf("output didn't produce the right output:\n\n%s", output)
+	}
+
+	// Split the log into lines
+	lines := strings.Split(output, "\n")
+
+	// Find the start of the teardown and complete timestamps
+	// The difference is the approximate duration of the test teardown operation.
+	// This test is running in parallel, so we expect the teardown to also run in parallel.
+	// We sleep for 3 seconds in the test teardown to simulate a long-running destroy.
+	// There are 6 unique state keys in the parallel test, so we expect the teardown to take less than 3*6 (18) seconds.
+	var startTimestamp, completeTimestamp string
+	for _, line := range lines {
+		if strings.Contains(line, `{"path":"parallel.tftest.hcl","progress":"teardown"`) {
+			var obj map[string]interface{}
+			if err := json.Unmarshal([]byte(line), &obj); err == nil {
+				if ts, ok := obj["@timestamp"].(string); ok {
+					startTimestamp = ts
+				}
+			}
+		} else if strings.Contains(line, `{"path":"parallel.tftest.hcl","progress":"complete"`) {
+			var obj map[string]interface{}
+			if err := json.Unmarshal([]byte(line), &obj); err == nil {
+				if ts, ok := obj["@timestamp"].(string); ok {
+					completeTimestamp = ts
+				}
+			}
+		}
+	}
+
+	if startTimestamp == "" || completeTimestamp == "" {
+		t.Fatalf("could not find start or complete timestamp in log output")
+	}
+
+	startTime, err := time.Parse(time.RFC3339Nano, startTimestamp)
+	if err != nil {
+		t.Fatalf("failed to parse start timestamp: %v", err)
+	}
+	completeTime, err := time.Parse(time.RFC3339Nano, completeTimestamp)
+	if err != nil {
+		t.Fatalf("failed to parse complete timestamp: %v", err)
+	}
+	dur := completeTime.Sub(startTime)
+	if dur > 10*time.Second {
+		t.Fatalf("parallel.tftest.hcl duration took too long: %0.2f seconds", dur.Seconds())
+	}
+}

internal/command/test_test.go

@@ -581,6 +581,7 @@ main.tftest.hcl/single, and they need to be cleaned up manually:
 		t.Errorf("expected err to be %s\n\nbut got %s\n\n diff:%s\n", cleanupErr, err, diff)
 	}
 	if diff := cmp.Diff(cleanupMessage, output.Stdout()); diff != "" {
+		fmt.Printf("expected output to be %s\n\nbut got %s\n\n diff:%s\n", cleanupMessage, output.Stdout(), diff)
 		t.Errorf("expected output to be %s\n\nbut got %s\n\n diff:%s\n", cleanupMessage, output.Stdout(), diff)
 	}
 

internal/command/testdata/test/parallel/main.tf

@@ -5,6 +5,7 @@ variable "input" {
 
 resource "test_resource" "foo" {
   value = var.input
+  destroy_wait_seconds = 3
 }
 
 output "value" {

internal/command/testdata/test/parallel/parallel.tftest.hcl

@@ -515,10 +515,3 @@ run "test_30" {
     error_message = "error in test_30"
   }
 }
-
-// Expected order:
-//   - run [setup]
-//   - run [test_a, test_d]
-//   - run [test_b]
-//   - run [test_c]
-

internal/command/testing/test_provider.go

@@ -133,6 +133,7 @@ func NewProvider(store *ResourceStore) *TestProvider {
 	provider.Provider.CallFunctionFn = provider.CallFunction
 	provider.Provider.OpenEphemeralResourceFn = provider.OpenEphemeralResource
 	provider.Provider.CloseEphemeralResourceFn = provider.CloseEphemeralResource
+	provider.Provider.NoLock = store.Nolock
 
 	return provider
 }
@@ -192,8 +193,7 @@ func (provider *TestProvider) DataSourceCount() int {
 }
 
 func (provider *TestProvider) count(prefix string) int {
-	provider.Store.mutex.RLock()
-	defer provider.Store.mutex.RUnlock()
+	defer provider.Store.beginRead()()
 
 	if len(prefix) == 0 {
 		return len(provider.Store.Data)
@@ -209,8 +209,7 @@ func (provider *TestProvider) count(prefix string) int {
 }
 
 func (provider *TestProvider) string(prefix string) string {
-	provider.Store.mutex.RLock()
-	defer provider.Store.mutex.RUnlock()
+	defer provider.Store.beginRead()()
 
 	var keys []string
 	for key := range provider.Store.Data {
@@ -393,14 +392,14 @@ func (provider *TestProvider) CloseEphemeralResource(providers.CloseEphemeralRes
 // For example, when the test provider gets a ReadResource request it will search
 // the store for a resource with a matching ID. See (*TestProvider).ReadResource.
 type ResourceStore struct {
-	mutex sync.RWMutex
+	mutex  sync.RWMutex
+	Nolock bool // nolock is used to disable locking
 
 	Data map[string]cty.Value
 }
 
 func (store *ResourceStore) Delete(key string) cty.Value {
-	store.mutex.Lock()
-	defer store.mutex.Unlock()
+	defer store.beginWrite()()
 
 	if resource, ok := store.Data[key]; ok {
 		delete(store.Data, key)
@@ -410,15 +409,13 @@ func (store *ResourceStore) Delete(key string) cty.Value {
 }
 
 func (store *ResourceStore) Get(key string) cty.Value {
-	store.mutex.RLock()
-	defer store.mutex.RUnlock()
+	defer store.beginRead()()
 
 	return store.get(key)
 }
 
 func (store *ResourceStore) Put(key string, resource cty.Value) cty.Value {
-	store.mutex.Lock()
-	defer store.mutex.Unlock()
+	defer store.beginWrite()()
 
 	old := store.get(key)
 	store.Data[key] = resource
@@ -431,3 +428,19 @@ func (store *ResourceStore) get(key string) cty.Value {
 	}
 	return cty.NilVal
 }
+
+func (store *ResourceStore) beginWrite() func() {
+	if store.Nolock {
+		return func() {}
+	}
+	store.mutex.Lock()
+	return store.mutex.Unlock
+
+}
+func (store *ResourceStore) beginRead() func() {
+	if store.Nolock {
+		return func() {}
+	}
+	store.mutex.RLock()
+	return store.mutex.RUnlock
+}

internal/moduletest/graph/node_state_cleanup.go

@@ -136,11 +136,7 @@ func (n *NodeStateCleanup) destroy(ctx *EvalContext, runNode *NodeTestRun, waite
 		Overrides:    mocking.PackageOverrides(run.Config, file.Config, run.ModuleConfig),
 	}
 
-	tfCtx, ctxDiags := terraform.NewContext(n.opts.ContextOpts)
-	diags = diags.Append(ctxDiags)
-	if ctxDiags.HasErrors() {
-		return state, diags
-	}
+	tfCtx, _ := terraform.NewContext(n.opts.ContextOpts)
 	ctx.Renderer().Run(run, file, moduletest.TearDown, 0)
 
 	waiter.update(tfCtx, moduletest.TearDown, nil)