refactor(variable-set): Iterator pattern and test cases were updated for variable-set and variable-set-variables

Author: isivaselvan

examples/variable_sets.py

@@ -64,7 +64,7 @@ def variable_set_example():
         list_options = VariableSetListOptions(
             page_size=10, include=[VariableSetIncludeOpt.WORKSPACES]
         )
-        variable_sets = client.variable_sets.list(org_name, list_options)
+        variable_sets = list(client.variable_sets.list(org_name, list_options))
         print(f"Found {len(variable_sets)} existing variable sets")
 
         for vs in variable_sets[:3]:  # Show first 3
@@ -92,6 +92,15 @@ def variable_set_example():
         print(f"Priority: {new_variable_set.priority}")
         print()
 
+        print("Listing existing variable sets...")
+        list_options = VariableSetListOptions(page_size=10)
+        variable_sets = list(client.variable_sets.list(org_name, list_options))
+        print(f"Found {len(variable_sets)} existing variable sets")
+
+        for vs in variable_sets:  # Show first 3
+            print(f"- {vs.name} (ID: {vs.id}, Global: {vs.global_})")
+        print()
+
         # 3. Create variables in the variable set
         print("3. Creating variables in the variable set...")
 
@@ -147,12 +156,16 @@ def variable_set_example():
         # 4. List variables in the variable set
         print("4. Listing variables in the variable set...")
         var_list_options = VariableSetVariableListOptions(page_size=50)
-        variables = client.variable_set_variables.list(
-            created_variable_set_id, var_list_options
+        variables = list(
+            client.variable_set_variables.list(
+                created_variable_set_id, var_list_options
+            )
         )
         print(f"Found {len(variables)} variables in the set:")
 
-        for var in variables:
+        for var in client.variable_set_variables.list(
+            created_variable_set_id, var_list_options
+        ):
             sensitive_note = " (sensitive)" if var.sensitive else ""
             hcl_note = " (HCL)" if var.hcl else ""
             print(f"- {var.key}: {var.category.value}{sensitive_note}{hcl_note}")
@@ -212,10 +225,14 @@ def variable_set_example():
                 print("Successfully applied to workspace")
 
                 # List variable sets for this workspace
-                workspace_varsets = client.variable_sets.list_for_workspace(
+                print(f"Listing variable sets for workspace: {first_workspace.name}")
+                workspace_varsets = 0
+                for ws_varset in client.variable_sets.list_for_workspace(
                     first_workspace.id
-                )
-                print(f"Workspace now has {len(workspace_varsets)} variable sets")
+                ):
+                    print(f"- {ws_varset.name} (ID: {ws_varset.id})")
+                    workspace_varsets += 1
+                print(f"Workspace now has {workspace_varsets} variable sets")
 
                 # Remove from workspace
                 remove_ws_options = VariableSetRemoveFromWorkspacesOptions(
@@ -250,10 +267,14 @@ def variable_set_example():
                 print("Successfully applied to project")
 
                 # List variable sets for this project
-                project_varsets = client.variable_sets.list_for_project(
+                print(f"Listing variable sets for project: {first_project.name}")
+                project_varsets = 0
+                for proj_varset in client.variable_sets.list_for_project(
                     first_project.id
-                )
-                print(f"Project now has {len(project_varsets)} variable sets")
+                ):
+                    print(f"- {proj_varset.name} (ID: {proj_varset.id})")
+                    project_varsets += 1
+                print(f"Project now has {project_varsets} variable sets")
 
                 # Remove from project
                 remove_proj_options = VariableSetRemoveFromProjectsOptions(

src/pytfe/models/variable_set.py

@@ -69,7 +69,6 @@ class VariableSetListOptions(BaseModel):
     """Options for listing variable sets."""
 
     # Pagination options
-    page_number: int | None = None
     page_size: int | None = None
     include: list[VariableSetIncludeOpt] | None = None
     query: str | None = None  # Filter by name

src/pytfe/resources/variable_sets.py

@@ -1,6 +1,7 @@
 """Variable Set resource implementation for the Python TFE SDK."""
 
 import builtins
+from collections.abc import Iterator
 from typing import Any
 
 from .._http import HTTPTransport
@@ -48,16 +49,15 @@ def list(
         self,
         organization: str,
         options: VariableSetListOptions | None = None,
-    ) -> list[VariableSet]:
+    ) -> Iterator[VariableSet]:
         """List all variable sets within an organization.
 
         Args:
             organization: Organization name
             options: Optional parameters for filtering and pagination
 
         Returns:
-            List of VariableSet objects
-
+            Iterator of VariableSet objects within the organization
         Raises:
             ValueError: If organization name is invalid
             TFEError: If API request fails
@@ -69,33 +69,29 @@ def list(
         params: dict[str, str] = {}
 
         if options:
-            if options.page_number:
-                params["page[number]"] = str(options.page_number)
             if options.page_size:
                 params["page[size]"] = str(options.page_size)
             if options.query:
                 params["q"] = options.query
             if options.include:
                 params["include"] = ",".join([opt.value for opt in options.include])
 
-        response = self.t.request("GET", path, params=params)
-        data = response.json()
-
-        return self._parse_variable_sets_response(data)
+        for item in self._list(path, params=params):
+            yield self._parse_variable_set(item)
 
     def list_for_workspace(
         self,
         workspace_id: str,
         options: VariableSetListOptions | None = None,
-    ) -> builtins.list[VariableSet]:
+    ) -> Iterator[VariableSet]:
         """List variable sets associated with a workspace.
 
         Args:
             workspace_id: Workspace ID
             options: Optional parameters for filtering and pagination
 
         Returns:
-            List of VariableSet objects associated with the workspace
+            Iterator of VariableSet objects associated with the workspace
 
         Raises:
             ValueError: If workspace_id is invalid
@@ -108,33 +104,29 @@ def list_for_workspace(
         params: dict[str, str] = {}
 
         if options:
-            if options.page_number:
-                params["page[number]"] = str(options.page_number)
             if options.page_size:
                 params["page[size]"] = str(options.page_size)
             if options.query:
                 params["q"] = options.query
             if options.include:
                 params["include"] = ",".join([opt.value for opt in options.include])
 
-        response = self.t.request("GET", path, params=params)
-        data = response.json()
-
-        return self._parse_variable_sets_response(data)
+        for item in self._list(path, params=params):
+            yield self._parse_variable_set(item)
 
     def list_for_project(
         self,
         project_id: str,
         options: VariableSetListOptions | None = None,
-    ) -> builtins.list[VariableSet]:
+    ) -> Iterator[VariableSet]:
         """List variable sets associated with a project.
 
         Args:
             project_id: Project ID
             options: Optional parameters for filtering and pagination
 
         Returns:
-            List of VariableSet objects associated with the project
+            Iterator of VariableSet objects associated with the project
 
         Raises:
             ValueError: If project_id is invalid
@@ -147,19 +139,15 @@ def list_for_project(
         params: dict[str, str] = {}
 
         if options:
-            if options.page_number:
-                params["page[number]"] = str(options.page_number)
             if options.page_size:
                 params["page[size]"] = str(options.page_size)
             if options.query:
                 params["q"] = options.query
             if options.include:
                 params["include"] = ",".join([opt.value for opt in options.include])
 
-        response = self.t.request("GET", path, params=params)
-        data = response.json()
-
-        return self._parse_variable_sets_response(data)
+        for item in self._list(path, params=params):
+            yield self._parse_variable_set(item)
 
     def create(
         self,
@@ -714,15 +702,15 @@ def list(
         self,
         variable_set_id: str,
         options: VariableSetVariableListOptions | None = None,
-    ) -> list[VariableSetVariable]:
+    ) -> Iterator[VariableSetVariable]:
         """List all variables in a variable set.
 
         Args:
             variable_set_id: Variable set ID
             options: Optional parameters for pagination
 
         Returns:
-            List of VariableSetVariable objects
+            Iterator of VariableSetVariable objects
 
         Raises:
             ValueError: If variable_set_id is invalid
@@ -735,19 +723,11 @@ def list(
         params: dict[str, str] = {}
 
         if options:
-            if options.page_number:
-                params["page[number]"] = str(options.page_number)
             if options.page_size:
                 params["page[size]"] = str(options.page_size)
 
-        response = self.t.request("GET", path, params=params)
-        data = response.json()
-
-        variables = []
-        for item in data.get("data", []):
-            variables.append(self._parse_variable_set_variable(item))
-
-        return variables
+        for item in self._list(path, params=params):
+            yield self._parse_variable_set_variable(item)
 
     def create(
         self,

tests/units/test_variable_sets.py

@@ -72,7 +72,7 @@ def test_list_variable_sets_success(self):
         self.mock_transport.request.return_value = mock_response
 
         # Call the method
-        result = self.variable_sets_service.list(self.org_name)
+        result = list(self.variable_sets_service.list(self.org_name))
 
         # Assertions
         assert len(result) == 1
@@ -85,7 +85,9 @@ def test_list_variable_sets_success(self):
 
         # Verify API call
         self.mock_transport.request.assert_called_once_with(
-            "GET", f"/api/v2/organizations/{self.org_name}/varsets", params={}
+            "GET",
+            f"/api/v2/organizations/{self.org_name}/varsets",
+            params={"page[number]": 1, "page[size]": 100},
         )
 
     def test_list_variable_sets_with_options(self):
@@ -97,21 +99,20 @@ def test_list_variable_sets_with_options(self):
 
         # Create options
         options = VariableSetListOptions(
-            page_number=2,
             page_size=50,
             query="test",
             include=[VariableSetIncludeOpt.WORKSPACES, VariableSetIncludeOpt.PROJECTS],
         )
 
         # Call the method
-        result = self.variable_sets_service.list(self.org_name, options)
+        result = list(self.variable_sets_service.list(self.org_name, options))
 
         # Verify the result
         assert isinstance(result, list)
 
         # Verify API call with parameters
         expected_params = {
-            "page[number]": "2",
+            "page[number]": 1,
             "page[size]": "50",
             "q": "test",
             "include": "workspaces,projects",
@@ -125,10 +126,10 @@ def test_list_variable_sets_with_options(self):
     def test_list_variable_sets_invalid_organization(self):
         """Test listing variable sets with invalid organization."""
         with pytest.raises(ValueError, match="Organization name is required"):
-            self.variable_sets_service.list("")
+            list(self.variable_sets_service.list(""))
 
         with pytest.raises(ValueError, match="Organization name is required"):
-            self.variable_sets_service.list(None)
+            list(self.variable_sets_service.list(None))
 
     def test_list_for_workspace_success(self):
         """Test successful listing of variable sets for workspace."""
@@ -152,21 +153,23 @@ def test_list_for_workspace_success(self):
         self.mock_transport.request.return_value = mock_response
 
         # Call the method
-        result = self.variable_sets_service.list_for_workspace(self.workspace_id)
+        result = list(self.variable_sets_service.list_for_workspace(self.workspace_id))
 
         # Assertions
         assert len(result) == 1
         assert result[0].name == "workspace-varset"
 
         # Verify API call
         self.mock_transport.request.assert_called_once_with(
-            "GET", f"/api/v2/workspaces/{self.workspace_id}/varsets", params={}
+            "GET",
+            f"/api/v2/workspaces/{self.workspace_id}/varsets",
+            params={"page[number]": 1, "page[size]": 100},
         )
 
     def test_list_for_workspace_invalid_id(self):
         """Test listing for workspace with invalid workspace ID."""
         with pytest.raises(ValueError, match="Workspace ID is required"):
-            self.variable_sets_service.list_for_workspace("")
+            list(self.variable_sets_service.list_for_workspace(""))
 
     def test_list_for_project_success(self):
         """Test successful listing of variable sets for project."""
@@ -190,21 +193,23 @@ def test_list_for_project_success(self):
         self.mock_transport.request.return_value = mock_response
 
         # Call the method
-        result = self.variable_sets_service.list_for_project(self.project_id)
+        result = list(self.variable_sets_service.list_for_project(self.project_id))
 
         # Assertions
         assert len(result) == 1
         assert result[0].name == "project-varset"
 
         # Verify API call
         self.mock_transport.request.assert_called_once_with(
-            "GET", f"/api/v2/projects/{self.project_id}/varsets", params={}
+            "GET",
+            f"/api/v2/projects/{self.project_id}/varsets",
+            params={"page[number]": 1, "page[size]": 100},
         )
 
     def test_list_for_project_invalid_id(self):
         """Test listing for project with invalid project ID."""
         with pytest.raises(ValueError, match="Project ID is required"):
-            self.variable_sets_service.list_for_project("")
+            list(self.variable_sets_service.list_for_project(""))
 
     def test_create_variable_set_success(self):
         """Test successful variable set creation."""
@@ -731,7 +736,7 @@ def test_list_variables_success(self):
         self.mock_transport.request.return_value = mock_response
 
         # Call the method
-        result = self.variables_service.list(self.variable_set_id)
+        result = list(self.variables_service.list(self.variable_set_id))
 
         # Assertions
         assert len(result) == 1
@@ -748,13 +753,13 @@ def test_list_variables_success(self):
         self.mock_transport.request.assert_called_once_with(
             "GET",
             f"/api/v2/varsets/{self.variable_set_id}/relationships/vars",
-            params={},
+            params={"page[number]": 1, "page[size]": 100},
         )
 
     def test_list_variables_invalid_varset_id(self):
         """Test listing variables with invalid variable set ID."""
         with pytest.raises(ValueError, match="Variable set ID is required"):
-            self.variables_service.list("")
+            list(self.variables_service.list(""))
 
     def test_create_variable_success(self):
         """Test successful variable creation."""