data_source hosted runner: fix review

Author: nico34638

github/data_source_github_enterprise_actions_hosted_runner.go

@@ -2,33 +2,33 @@ package github
 
 import (
 	"context"
-	"fmt"
+	"strconv"
 	"time"
 
-	"github.com/google/go-github/v82/github"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
 func dataSourceGithubEnterpriseActionsHostedRunner() *schema.Resource {
 	return &schema.Resource{
-		Read: dataSourceGithubEnterpriseActionsHostedRunnerRead,
+		ReadContext: dataSourceGithubEnterpriseActionsHostedRunnerRead,
 
 		Schema: map[string]*schema.Schema{
 			"enterprise_slug": {
 				Type:        schema.TypeString,
 				Required:    true,
 				Description: "The slug of the enterprise.",
 			},
-			"name": {
-				Type:        schema.TypeString,
-				Required:    true,
-				Description: "The name of the hosted runner to lookup.",
-			},
 			"runner_id": {
 				Type:        schema.TypeInt,
-				Computed:    true,
+				Required:    true,
 				Description: "The numeric ID of the hosted runner.",
 			},
+			"name": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The name of the hosted runner.",
+			},
 			"runner_group_id": {
 				Type:        schema.TypeInt,
 				Computed:    true,
@@ -150,100 +150,44 @@ func dataSourceGithubEnterpriseActionsHostedRunner() *schema.Resource {
 	}
 }
 
-func dataSourceGithubEnterpriseActionsHostedRunnerRead(d *schema.ResourceData, meta any) error {
+func dataSourceGithubEnterpriseActionsHostedRunnerRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	client := meta.(*Owner).v3client
-	ctx := context.Background()
 
 	enterpriseSlug := d.Get("enterprise_slug").(string)
-	runnerName := d.Get("name").(string)
-
-	// List all runners and find the one matching the name
-	opts := &github.ListOptions{PerPage: 100}
-	var foundRunner *github.HostedRunner
+	runnerID := int64(d.Get("runner_id").(int))
 
-	for {
-		runners, resp, err := client.Enterprise.ListHostedRunners(ctx, enterpriseSlug, opts)
-		if err != nil {
-			return err
-		}
-
-		for _, runner := range runners.Runners {
-			if runner.Name != nil && *runner.Name == runnerName {
-				foundRunner = runner
-				break
-			}
-		}
-
-		if foundRunner != nil || resp.NextPage == 0 {
-			break
-		}
-		opts.Page = resp.NextPage
-	}
-
-	if foundRunner == nil {
-		return fmt.Errorf("no hosted runner found with name %q in enterprise %q", runnerName, enterpriseSlug)
+	// Get the specific runner by ID
+	runner, _, err := client.Enterprise.GetHostedRunner(ctx, enterpriseSlug, runnerID)
+	if err != nil {
+		return diag.Errorf("error reading enterprise hosted runner: %s", err.Error())
 	}
 
 	// Set the ID as enterprise_slug/runner_id
-	d.SetId(fmt.Sprintf("%s/%d", enterpriseSlug, *foundRunner.ID))
-
-	if foundRunner.ID != nil {
-		if err := d.Set("runner_id", int(*foundRunner.ID)); err != nil {
-			return err
-		}
+	id, err := buildID(enterpriseSlug, strconv.FormatInt(runner.GetID(), 10))
+	if err != nil {
+		return diag.FromErr(err)
 	}
-
-	if foundRunner.RunnerGroupID != nil {
-		if err := d.Set("runner_group_id", int(*foundRunner.RunnerGroupID)); err != nil {
-			return err
-		}
-	}
-
-	if foundRunner.Platform != nil {
-		if err := d.Set("platform", *foundRunner.Platform); err != nil {
-			return err
-		}
-	}
-
-	if foundRunner.Status != nil {
-		if err := d.Set("status", *foundRunner.Status); err != nil {
-			return err
-		}
-	}
-
-	if foundRunner.MaximumRunners != nil {
-		if err := d.Set("maximum_runners", int(*foundRunner.MaximumRunners)); err != nil {
-			return err
-		}
+	d.SetId(id)
+
+	runnerData := map[string]any{
+		"name":                 runner.GetName(),
+		"runner_group_id":      int(runner.GetRunnerGroupID()),
+		"platform":             runner.GetPlatform(),
+		"status":               runner.GetStatus(),
+		"maximum_runners":      int(runner.GetMaximumRunners()),
+		"public_ip_enabled":    runner.GetPublicIPEnabled(),
+		"image_details":        flattenHostedRunnerImage(runner.ImageDetails),
+		"machine_size_details": flattenHostedRunnerMachineSpec(runner.MachineSizeDetails),
+		"public_ips":           flattenHostedRunnerPublicIPs(runner.PublicIPs),
 	}
 
-	if foundRunner.PublicIPEnabled != nil {
-		if err := d.Set("public_ip_enabled", *foundRunner.PublicIPEnabled); err != nil {
-			return err
-		}
-	}
-
-	if foundRunner.LastActiveOn != nil {
-		if err := d.Set("last_active_on", foundRunner.LastActiveOn.Format(time.RFC3339)); err != nil {
-			return err
-		}
-	}
-
-	if foundRunner.ImageDetails != nil {
-		if err := d.Set("image_details", flattenHostedRunnerImage(foundRunner.ImageDetails)); err != nil {
-			return err
-		}
-	}
-
-	if foundRunner.MachineSizeDetails != nil {
-		if err := d.Set("machine_size_details", flattenHostedRunnerMachineSpec(foundRunner.MachineSizeDetails)); err != nil {
-			return err
-		}
+	if runner.LastActiveOn != nil {
+		runnerData["last_active_on"] = runner.LastActiveOn.Format(time.RFC3339)
 	}
 
-	if foundRunner.PublicIPs != nil {
-		if err := d.Set("public_ips", flattenHostedRunnerPublicIPs(foundRunner.PublicIPs)); err != nil {
-			return err
+	for k, v := range runnerData {
+		if err := d.Set(k, v); err != nil {
+			return diag.FromErr(err)
 		}
 	}
 

github/data_source_github_enterprise_actions_hosted_runner_test.go

@@ -4,34 +4,11 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 )
 
-func TestAccGithubEnterpriseActionsHostedRunnersDataSource(t *testing.T) {
-	t.Run("lists all enterprise hosted runners", func(t *testing.T) {
-		config := fmt.Sprintf(`
-			data "github_enterprise_actions_hosted_runners" "test" {
-				enterprise_slug = "%s"
-			}
-		`, testAccConf.enterpriseSlug)
-
-		resource.Test(t, resource.TestCase{
-			PreCheck:          func() { skipUnlessMode(t, enterprise) },
-			ProviderFactories: providerFactories,
-			Steps: []resource.TestStep{
-				{
-					Config: config,
-					Check: resource.ComposeTestCheckFunc(
-						resource.TestCheckResourceAttrSet("data.github_enterprise_actions_hosted_runners.test", "runners.#"),
-					),
-				},
-			},
-		})
-	})
-}
-
 func TestAccGithubEnterpriseActionsHostedRunnerDataSource(t *testing.T) {
-	t.Run("gets a specific enterprise hosted runner by name", func(t *testing.T) {
+	t.Run("gets a specific enterprise hosted runner by ID", func(t *testing.T) {
 		config := fmt.Sprintf(`
 			data "github_enterprise" "enterprise" {
 				slug = "%s"
@@ -58,7 +35,7 @@ func TestAccGithubEnterpriseActionsHostedRunnerDataSource(t *testing.T) {
 
 			data "github_enterprise_actions_hosted_runner" "test" {
 				enterprise_slug = data.github_enterprise.enterprise.slug
-				name            = github_enterprise_actions_hosted_runner.test.name
+				runner_id       = github_enterprise_actions_hosted_runner.test.runner_id
 			}
 		`, testAccConf.enterpriseSlug)
 

github/data_source_github_enterprise_actions_hosted_runners.go

@@ -5,12 +5,13 @@ import (
 	"time"
 
 	"github.com/google/go-github/v82/github"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
 func dataSourceGithubEnterpriseActionsHostedRunners() *schema.Resource {
 	return &schema.Resource{
-		Read: dataSourceGithubEnterpriseActionsHostedRunnersRead,
+		ReadContext: dataSourceGithubEnterpriseActionsHostedRunnersRead,
 
 		Schema: map[string]*schema.Schema{
 			"enterprise_slug": {
@@ -134,20 +135,19 @@ func dataSourceGithubEnterpriseActionsHostedRunners() *schema.Resource {
 	}
 }
 
-func dataSourceGithubEnterpriseActionsHostedRunnersRead(d *schema.ResourceData, meta any) error {
+func dataSourceGithubEnterpriseActionsHostedRunnersRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	client := meta.(*Owner).v3client
-	ctx := context.Background()
 
 	enterpriseSlug := d.Get("enterprise_slug").(string)
 
 	// List all hosted runners with pagination
-	opts := &github.ListOptions{PerPage: 100}
+	opts := &github.ListOptions{PerPage: maxPerPage}
 	var allRunners []*github.HostedRunner
 
 	for {
 		runners, resp, err := client.Enterprise.ListHostedRunners(ctx, enterpriseSlug, opts)
 		if err != nil {
-			return err
+			return diag.Errorf("error listing enterprise hosted runners: %s", err.Error())
 		}
 
 		allRunners = append(allRunners, runners.Runners...)
@@ -161,9 +161,8 @@ func dataSourceGithubEnterpriseActionsHostedRunnersRead(d *schema.ResourceData,
 	// Set the ID as the enterprise slug
 	d.SetId(enterpriseSlug)
 
-	// Flatten runners data
 	if err := d.Set("runners", flattenHostedRunners(allRunners)); err != nil {
-		return err
+		return diag.FromErr(err)
 	}
 
 	return nil
@@ -182,27 +181,14 @@ func flattenHostedRunners(runners []*github.HostedRunner) []any {
 
 		runnerMap := make(map[string]any)
 
-		if runner.ID != nil {
-			runnerMap["id"] = int(*runner.ID)
-		}
-		if runner.Name != nil {
-			runnerMap["name"] = *runner.Name
-		}
-		if runner.RunnerGroupID != nil {
-			runnerMap["runner_group_id"] = int(*runner.RunnerGroupID)
-		}
-		if runner.Platform != nil {
-			runnerMap["platform"] = *runner.Platform
-		}
-		if runner.Status != nil {
-			runnerMap["status"] = *runner.Status
-		}
-		if runner.MaximumRunners != nil {
-			runnerMap["maximum_runners"] = int(*runner.MaximumRunners)
-		}
-		if runner.PublicIPEnabled != nil {
-			runnerMap["public_ip_enabled"] = *runner.PublicIPEnabled
-		}
+		runnerMap["id"] = int(runner.GetID())
+		runnerMap["name"] = runner.GetName()
+		runnerMap["runner_group_id"] = int(runner.GetRunnerGroupID())
+		runnerMap["platform"] = runner.GetPlatform()
+		runnerMap["status"] = runner.GetStatus()
+		runnerMap["maximum_runners"] = int(runner.GetMaximumRunners())
+		runnerMap["public_ip_enabled"] = runner.GetPublicIPEnabled()
+
 		if runner.LastActiveOn != nil {
 			runnerMap["last_active_on"] = runner.LastActiveOn.Format(time.RFC3339)
 		}

github/data_source_github_enterprise_actions_hosted_runners_test.go

@@ -0,0 +1,31 @@
+package github
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+)
+
+func TestAccGithubEnterpriseActionsHostedRunnersDataSource(t *testing.T) {
+	t.Run("lists all enterprise hosted runners", func(t *testing.T) {
+		config := fmt.Sprintf(`
+			data "github_enterprise_actions_hosted_runners" "test" {
+				enterprise_slug = "%s"
+			}
+		`, testAccConf.enterpriseSlug)
+
+		resource.Test(t, resource.TestCase{
+			PreCheck:          func() { skipUnlessMode(t, enterprise) },
+			ProviderFactories: providerFactories,
+			Steps: []resource.TestStep{
+				{
+					Config: config,
+					Check: resource.ComposeTestCheckFunc(
+						resource.TestCheckResourceAttrSet("data.github_enterprise_actions_hosted_runners.test", "runners.#"),
+					),
+				},
+			},
+		})
+	})
+}