[IPL-7725] Adding Support for Calls to /workspaces/{external_id}/all-vars API Endpoint on HCP Terraform (#1105)

* IPL-7725: Adding support for a new API to list all variables associated with a workspace including
variables that inherited from organization and/or project variable sets. The List API does not
include variables that are inherited from varsets but not overwritten in the workspace.

* [IPL-7725] Adding support for calling the /api/v2/workspaces/{id}/all-vars API
and adding integration tests

* [IPL-7725] Adding changelog entry

* [IPL-7725] Fixing lint issues - adding mock functions for ListAll API

---------

Co-authored-by: Amartya Majumdar <[email protected]>

Author: debrin-hc

CHANGELOG.md

@@ -1,4 +1,5 @@
 # Unreleased
+* Add support for HCP Terraform `/api/v2/workspaces/{external_id}/all-vars` API endpoint to fetch the list of all variables available to a workspace (include inherited variables from varsets) by @debrin-hc [#1105](https://github.com/hashicorp/go-tfe/pull/1105)
 
 # v1.82.0
 

helper_test.go

@@ -2209,19 +2209,48 @@ func createTeamTokenWithOptions(t *testing.T, client *Client, tm *Team, options
 }
 
 func createVariable(t *testing.T, client *Client, w *Workspace) (*Variable, func()) {
+	options := VariableCreateOptions{
+		Key:         String(randomString(t)),
+		Value:       String(randomString(t)),
+		Category:    Category(CategoryTerraform),
+		Description: String(randomString(t)),
+	}
+	return createVariableWithOptions(t, client, w, options)
+}
+
+func createVariableWithOptions(t *testing.T, client *Client, w *Workspace, options VariableCreateOptions) (*Variable, func()) {
 	var wCleanup func()
 
 	if w == nil {
 		w, wCleanup = createWorkspace(t, client, nil)
 	}
 
+	if options.Key == nil {
+		options.Key = String(randomString(t))
+	}
+
+	if options.Value == nil {
+		options.Value = String(randomString(t))
+	}
+
+	if options.Description == nil {
+		options.Description = String(randomString(t))
+	}
+
+	if options.Category == nil {
+		options.Category = Category(CategoryTerraform)
+	}
+
+	if options.HCL == nil {
+		options.HCL = Bool(false)
+	}
+
+	if options.Sensitive == nil {
+		options.Sensitive = Bool(false)
+	}
+
 	ctx := context.Background()
-	v, err := client.Variables.Create(ctx, w.ID, VariableCreateOptions{
-		Key:         String(randomString(t)),
-		Value:       String(randomString(t)),
-		Category:    Category(CategoryTerraform),
-		Description: String(randomString(t)),
-	})
+	v, err := client.Variables.Create(ctx, w.ID, options)
 	if err != nil {
 		t.Fatal(err)
 	}

mocks/variable_mocks.go

@@ -17,9 +17,12 @@ var _ Variables = (*variables)(nil)
 //
 // TFE API docs: https://developer.hashicorp.com/terraform/cloud-docs/api-docs/workspace-variables
 type Variables interface {
-	// List all the variables associated with the given workspace.
+	// List all the variables associated with the given workspace (doesn't include variables inherited from varsets).
 	List(ctx context.Context, workspaceID string, options *VariableListOptions) (*VariableList, error)
 
+	// ListAll all the variables associated with the given workspace including variables inherited from varsets.
+	ListAll(ctx context.Context, workspaceID string, options *VariableListOptions) (*VariableList, error)
+
 	// Create is used to create a new variable.
 	Create(ctx context.Context, workspaceID string, options VariableCreateOptions) (*Variable, error)
 
@@ -128,13 +131,22 @@ type VariableUpdateOptions struct {
 	Sensitive *bool `jsonapi:"attr,sensitive,omitempty"`
 }
 
-// List all the variables associated with the given workspace.
+// List all the variables associated with the given workspace (doesn't include variables inherited from varsets).
 func (s *variables) List(ctx context.Context, workspaceID string, options *VariableListOptions) (*VariableList, error) {
+	return s.getList(ctx, workspaceID, options, "workspaces/%s/vars")
+}
+
+// ListAll the variables associated with the given workspace including variables inherited from varsets.
+func (s *variables) ListAll(ctx context.Context, workspaceID string, options *VariableListOptions) (*VariableList, error) {
+	return s.getList(ctx, workspaceID, options, "workspaces/%s/all-vars")
+}
+
+func (s *variables) getList(ctx context.Context, workspaceID string, options *VariableListOptions, path string) (*VariableList, error) {
 	if !validStringID(&workspaceID) {
 		return nil, ErrInvalidWorkspaceID
 	}
 
-	u := fmt.Sprintf("workspaces/%s/vars", url.PathEscape(workspaceID))
+	u := fmt.Sprintf(path, url.PathEscape(workspaceID))
 	req, err := s.client.NewRequest("GET", u, options)
 	if err != nil {
 		return nil, err

variable.go

@@ -61,6 +61,123 @@ func TestVariablesList(t *testing.T) {
 	})
 }
 
+func TestVariablesListAll(t *testing.T) {
+	client := testClient(t)
+	ctx := context.Background()
+
+	orgTest, orgTestCleanup := createOrganization(t, client)
+	t.Cleanup(orgTestCleanup)
+
+	prjTest, prjTestCleanup := createProject(t, client, orgTest)
+	t.Cleanup(prjTestCleanup)
+
+	wTest, wTestCleanup := createWorkspaceWithOptions(t, client, orgTest, WorkspaceCreateOptions{
+		Name:    String(randomString(t)),
+		Project: prjTest,
+	})
+	t.Cleanup(wTestCleanup)
+
+	orgVarset, orgVarsetCleanup := createVariableSet(t, client, orgTest, VariableSetCreateOptions{})
+	t.Cleanup(orgVarsetCleanup)
+
+	prjVarset, prjVarsetCleanup := createVariableSet(t, client, orgTest, VariableSetCreateOptions{
+		Parent: &Parent{
+			Organization: orgTest,
+			Project:      prjTest,
+		},
+	})
+	t.Cleanup(prjVarsetCleanup)
+
+	glVar, glVarCleanup := createVariableSetVariable(t, client, orgVarset, VariableSetVariableCreateOptions{
+		Key:         String("key1"),
+		Value:       String("gl_value1"),
+		Category:    Category(CategoryTerraform),
+		Description: String(randomString(t)),
+	})
+	t.Cleanup(glVarCleanup)
+
+	glVarOverwrite, glVarOverwriteCleanup := createVariableSetVariable(t, client, orgVarset, VariableSetVariableCreateOptions{
+		Key:         String("key2"),
+		Value:       String("gl_value2"),
+		Category:    Category(CategoryTerraform),
+		Description: String(randomString(t)),
+	})
+	t.Cleanup(glVarOverwriteCleanup)
+
+	prjVar, prjVarCleanup := createVariableSetVariable(t, client, prjVarset, VariableSetVariableCreateOptions{
+		Key:         String("key3"),
+		Value:       String("prj_value3"),
+		Category:    Category(CategoryTerraform),
+		Description: String(randomString(t)),
+	})
+	t.Cleanup(prjVarCleanup)
+
+	prjVarOverwrite, prjVarOverwriteCleanup := createVariableSetVariable(t, client, prjVarset, VariableSetVariableCreateOptions{
+		Key:         String("key4"),
+		Value:       String("prj_value4"),
+		Category:    Category(CategoryTerraform),
+		Description: String(randomString(t)),
+	})
+	t.Cleanup(prjVarOverwriteCleanup)
+
+	wsVar1, wsVar1Cleanup := createVariableWithOptions(t, client, wTest, VariableCreateOptions{
+		Key:         String("key2"),
+		Value:       String("ws_value2"),
+		Category:    Category(CategoryTerraform),
+		Description: String(randomString(t)),
+	})
+	t.Cleanup(wsVar1Cleanup)
+
+	wsVar2, wsVar2Cleanup := createVariableWithOptions(t, client, wTest, VariableCreateOptions{
+		Key:         String("key4"),
+		Value:       String("ws_value4"),
+		Category:    Category(CategoryTerraform),
+		Description: String(randomString(t)),
+	})
+	t.Cleanup(wsVar2Cleanup)
+
+	wsVar3, wsVar3Cleanup := createVariableWithOptions(t, client, wTest, VariableCreateOptions{
+		Key:         String("key5"),
+		Value:       String("ws_value5"),
+		Category:    Category(CategoryTerraform),
+		Description: String(randomString(t)),
+	})
+	t.Cleanup(wsVar3Cleanup)
+
+	applyVariableSetToWorkspace(t, client, orgVarset.ID, wTest.ID)
+	applyVariableSetToWorkspace(t, client, prjVarset.ID, wTest.ID)
+
+	t.Run("when /workspaces/{external_id}/all-vars API is called", func(t *testing.T) {
+		vl, err := client.Variables.ListAll(ctx, wTest.ID, nil)
+		require.NoError(t, err)
+		assert.NotNilf(t, vl, "expected to get a non-empty variables list")
+
+		variableIDToValueMap := make(map[string]string)
+		for _, variable := range vl.Items {
+			variableIDToValueMap[variable.ID] = variable.Value
+		}
+		assert.Equal(t, len(vl.Items), 5)
+		assert.NotContains(t, variableIDToValueMap, glVarOverwrite.ID)
+		assert.NotContains(t, variableIDToValueMap, prjVarOverwrite.ID)
+		assert.Contains(t, variableIDToValueMap, glVar.ID)
+		assert.Contains(t, variableIDToValueMap, prjVar.ID)
+		assert.Contains(t, variableIDToValueMap, wsVar1.ID)
+		assert.Contains(t, variableIDToValueMap, wsVar2.ID)
+		assert.Contains(t, variableIDToValueMap, wsVar3.ID)
+		assert.Equal(t, glVar.Value, variableIDToValueMap[glVar.ID])
+		assert.Equal(t, prjVar.Value, variableIDToValueMap[prjVar.ID])
+		assert.Equal(t, wsVar1.Value, variableIDToValueMap[wsVar1.ID])
+		assert.Equal(t, wsVar2.Value, variableIDToValueMap[wsVar2.ID])
+		assert.Equal(t, wsVar3.Value, variableIDToValueMap[wsVar3.ID])
+	})
+
+	t.Run("when workspace ID is invalid ID", func(t *testing.T) {
+		vl, err := client.Variables.ListAll(ctx, badIdentifier, nil)
+		assert.Nilf(t, vl, "expected variables list to be nil")
+		assert.EqualError(t, err, ErrInvalidWorkspaceID.Error())
+	})
+}
+
 func TestVariablesCreate(t *testing.T) {
 	client := testClient(t)
 	ctx := context.Background()