Renames, style changes and unexports (#3)

actions_server_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"net/http"

byte_order_mark_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"io"
@@ -6,7 +6,6 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/actions/scaleset"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -18,13 +17,13 @@ func TestClient_Do(t *testing.T) {
 			}))
 			defer server.Close()
 
-			client, err := scaleset.NewClient("https://localhost/org/repo", &scaleset.ActionsAuth{Token: "token"})
+			client, err := NewClient("https://localhost/org/repo", &ActionsAuth{Token: "token"})
 			require.NoError(t, err)
 
 			req, err := http.NewRequest("GET", server.URL, nil)
 			require.NoError(t, err)
 
-			resp, err := client.Do(req)
+			resp, err := client.do(req)
 			require.NoError(t, err)
 
 			body, err := io.ReadAll(resp.Body)
@@ -44,13 +43,13 @@ func TestClient_Do(t *testing.T) {
 			}))
 			defer server.Close()
 
-			client, err := scaleset.NewClient("https://localhost/org/repo", &scaleset.ActionsAuth{Token: "token"})
+			client, err := NewClient("https://localhost/org/repo", &ActionsAuth{Token: "token"})
 			require.NoError(t, err)
 
 			req, err := http.NewRequest("GET", server.URL, nil)
 			require.NoError(t, err)
 
-			resp, err := client.Do(req)
+			resp, err := client.do(req)
 			require.NoError(t, err)
 
 			body, err := io.ReadAll(resp.Body)

client_generate_jit_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"context"
@@ -6,27 +6,26 @@ import (
 	"testing"
 	"time"
 
-	"github.com/actions/scaleset"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestGenerateJitRunnerConfig(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	t.Run("Get JIT Config for Runner", func(t *testing.T) {
-		want := &scaleset.RunnerScaleSetJitRunnerConfig{}
+		want := &RunnerScaleSetJitRunnerConfig{}
 		response := []byte(`{"count":1,"value":[{"id":1,"name":"scale-set-name"}]}`)
 
-		runnerSettings := &scaleset.RunnerScaleSetJitRunnerSetting{}
+		runnerSettings := &RunnerScaleSetJitRunnerSetting{}
 
 		server := newActionsServer(t, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 			w.Write(response)
 		}))
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GenerateJitRunnerConfig(ctx, runnerSettings, 1)
@@ -35,7 +34,7 @@ func TestGenerateJitRunnerConfig(t *testing.T) {
 	})
 
 	t.Run("Default retries on server error", func(t *testing.T) {
-		runnerSettings := &scaleset.RunnerScaleSetJitRunnerSetting{}
+		runnerSettings := &RunnerScaleSetJitRunnerSetting{}
 
 		retryMax := 1
 		actualRetry := 0
@@ -46,11 +45,11 @@ func TestGenerateJitRunnerConfig(t *testing.T) {
 			actualRetry++
 		}))
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(1),
+			WithRetryMax(1),
-			scaleset.WithRetryWaitMax(1*time.Millisecond),
+			WithRetryWaitMax(1*time.Millisecond),
 		)
 		require.NoError(t, err)
 

client_job_acquisition_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"context"
@@ -8,14 +8,13 @@ import (
 	"testing"
 	"time"
 
-	"github.com/actions/scaleset"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestAcquireJobs(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
@@ -23,8 +22,8 @@ func TestAcquireJobs(t *testing.T) {
 		want := []int64{1}
 		response := []byte(`{"value": [1]}`)
 
-		session := &scaleset.RunnerScaleSetSession{
+		session := &RunnerScaleSetSession{
-			RunnerScaleSet:          &scaleset.RunnerScaleSet{Id: 1},
+			RunnerScaleSet:          &RunnerScaleSet{ID: 1},
 			MessageQueueAccessToken: "abc",
 		}
 		requestIDs := want
@@ -38,23 +37,23 @@ func TestAcquireJobs(t *testing.T) {
 			w.Write(response)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetAcquirableJobs(ctx, 1)
 		require.NoError(t, err)
 
-		got, err := client.AcquireJobs(ctx, session.RunnerScaleSet.Id, session.MessageQueueAccessToken, requestIDs)
+		got, err := client.AcquireJobs(ctx, session.RunnerScaleSet.ID, session.MessageQueueAccessToken, requestIDs)
 		require.NoError(t, err)
 		assert.Equal(t, want, got)
 	})
 
 	t.Run("Default retries on server error", func(t *testing.T) {
-		session := &scaleset.RunnerScaleSetSession{
+		session := &RunnerScaleSetSession{
-			RunnerScaleSet:          &scaleset.RunnerScaleSet{Id: 1},
+			RunnerScaleSet:          &RunnerScaleSet{ID: 1},
 			MessageQueueAccessToken: "abc",
 		}
-		var requestIDs = []int64{1}
+		requestIDs := []int64{1}
 
 		retryMax := 1
 		actualRetry := 0
@@ -70,18 +69,18 @@ func TestAcquireJobs(t *testing.T) {
 			actualRetry++
 		}))
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(1*time.Millisecond),
+			WithRetryWaitMax(1*time.Millisecond),
 		)
 		require.NoError(t, err)
 
 		_, err = client.GetAcquirableJobs(ctx, 1)
 		require.NoError(t, err)
 
-		_, err = client.AcquireJobs(context.Background(), session.RunnerScaleSet.Id, session.MessageQueueAccessToken, requestIDs)
+		_, err = client.AcquireJobs(context.Background(), session.RunnerScaleSet.ID, session.MessageQueueAccessToken, requestIDs)
 		assert.NotNil(t, err)
 		assert.Equalf(t, actualRetry, expectedRetry, "A retry was expected after the first request but got: %v", actualRetry)
 	})
@@ -89,8 +88,8 @@ func TestAcquireJobs(t *testing.T) {
 	t.Run("Should return MessageQueueTokenExpiredError when http error is not Unauthorized", func(t *testing.T) {
 		want := []int64{1}
 
-		session := &scaleset.RunnerScaleSetSession{
+		session := &RunnerScaleSetSession{
-			RunnerScaleSet:          &scaleset.RunnerScaleSet{Id: 1},
+			RunnerScaleSet:          &RunnerScaleSet{ID: 1},
 			MessageQueueAccessToken: "abc",
 		}
 		requestIDs := want
@@ -106,45 +105,45 @@ func TestAcquireJobs(t *testing.T) {
 			}
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetAcquirableJobs(ctx, 1)
 		require.NoError(t, err)
 
-		got, err := client.AcquireJobs(ctx, session.RunnerScaleSet.Id, session.MessageQueueAccessToken, requestIDs)
+		got, err := client.AcquireJobs(ctx, session.RunnerScaleSet.ID, session.MessageQueueAccessToken, requestIDs)
 		require.Error(t, err)
 		assert.Nil(t, got)
-		var expectedErr *scaleset.MessageQueueTokenExpiredError
+		var expectedErr *MessageQueueTokenExpiredError
 		assert.True(t, errors.As(err, &expectedErr))
 	})
 }
 
 func TestGetAcquirableJobs(t *testing.T) {
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	t.Run("Acquire Job", func(t *testing.T) {
-		want := &scaleset.AcquirableJobList{}
+		want := &AcquirableJobList{}
 		response := []byte(`{"count": 0}`)
 
-		runnerScaleSet := &scaleset.RunnerScaleSet{Id: 1}
+		runnerScaleSet := &RunnerScaleSet{ID: 1}
 
 		server := newActionsServer(t, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 			w.Write(response)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		got, err := client.GetAcquirableJobs(context.Background(), runnerScaleSet.Id)
+		got, err := client.GetAcquirableJobs(context.Background(), runnerScaleSet.ID)
 		require.NoError(t, err)
 		assert.Equal(t, want, got)
 	})
 
 	t.Run("Default retries on server error", func(t *testing.T) {
-		runnerScaleSet := &scaleset.RunnerScaleSet{Id: 1}
+		runnerScaleSet := &RunnerScaleSet{ID: 1}
 
 		retryMax := 1
 
@@ -156,15 +155,15 @@ func TestGetAcquirableJobs(t *testing.T) {
 			actualRetry++
 		}))
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(1*time.Millisecond),
+			WithRetryWaitMax(1*time.Millisecond),
 		)
 		require.NoError(t, err)
 
-		_, err = client.GetAcquirableJobs(context.Background(), runnerScaleSet.Id)
+		_, err = client.GetAcquirableJobs(context.Background(), runnerScaleSet.ID)
 		require.Error(t, err)
 		assert.Equalf(t, actualRetry, expectedRetry, "A retry was expected after the first request but got: %v", actualRetry)
 	})

client_proxy_test.go

@@ -1,11 +1,10 @@
-package scaleset_test
+package scaleset
 
 import (
 	"net/http"
 	"net/url"
 	"testing"
 
-	"github.com/actions/scaleset"
 	"github.com/actions/scaleset/testserver"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -26,13 +25,13 @@ func TestClientProxy(t *testing.T) {
 		return proxyConfig.ProxyFunc()(req.URL)
 	}
 
-	c, err := scaleset.NewClient("http://github.com/org/repo", nil, scaleset.WithProxy(proxyFunc))
+	c, err := NewClient("http://github.com/org/repo", nil, WithProxy(proxyFunc))
 	require.NoError(t, err)
 
 	req, err := http.NewRequest(http.MethodGet, "http://example.com", nil)
 	require.NoError(t, err)
 
-	_, err = c.Do(req)
+	_, err = c.do(req)
 	require.NoError(t, err)
 
 	assert.True(t, serverCalled)

client_runner_scale_set_message_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"context"
@@ -9,20 +9,19 @@ import (
 	"testing"
 	"time"
 
-	"github.com/actions/scaleset"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestGetMessage(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	token := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjI1MTYyMzkwMjJ9.tlrHslTmDkoqnc4Kk9ISoKoUNDfHo-kjlH-ByISBqzE"
-	runnerScaleSetMessage := &scaleset.RunnerScaleSetMessage{
+	runnerScaleSetMessage := &RunnerScaleSetMessage{
-		MessageId:   1,
+		MessageID:   1,
 		MessageType: "rssType",
 	}
 
@@ -33,7 +32,7 @@ func TestGetMessage(t *testing.T) {
 			w.Write(response)
 		}))
 
-		client, err := scaleset.NewClient(s.configURLForOrg("my-org"), auth)
+		client, err := NewClient(s.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GetMessage(ctx, s.URL, token, 0, 10)
@@ -50,7 +49,7 @@ func TestGetMessage(t *testing.T) {
 			w.Write(response)
 		}))
 
-		client, err := scaleset.NewClient(s.configURLForOrg("my-org"), auth)
+		client, err := NewClient(s.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GetMessage(ctx, s.URL, token, 1, 10)
@@ -69,11 +68,11 @@ func TestGetMessage(t *testing.T) {
 			actualRetry++
 		}))
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(1*time.Millisecond),
+			WithRetryWaitMax(1*time.Millisecond),
 		)
 		require.NoError(t, err)
 
@@ -87,18 +86,18 @@ func TestGetMessage(t *testing.T) {
 			w.WriteHeader(http.StatusUnauthorized)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetMessage(ctx, server.URL, token, 0, 10)
 		require.NotNil(t, err)
 
-		var expectedErr *scaleset.MessageQueueTokenExpiredError
+		var expectedErr *MessageQueueTokenExpiredError
 		require.True(t, errors.As(err, &expectedErr))
 	})
 
 	t.Run("Status code not found", func(t *testing.T) {
-		want := scaleset.ActionsError{
+		want := ActionsError{
 			Err:        errors.New("unknown exception"),
 			StatusCode: 404,
 		}
@@ -106,7 +105,7 @@ func TestGetMessage(t *testing.T) {
 			w.WriteHeader(http.StatusNotFound)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetMessage(ctx, server.URL, token, 0, 10)
@@ -120,7 +119,7 @@ func TestGetMessage(t *testing.T) {
 			w.Header().Set("Content-Type", "text/plain")
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetMessage(ctx, server.URL, token, 0, 10)
@@ -129,7 +128,7 @@ func TestGetMessage(t *testing.T) {
 
 	t.Run("Capacity error handling", func(t *testing.T) {
 		server := newActionsServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			hc := r.Header.Get(scaleset.HeaderScaleSetMaxCapacity)
+			hc := r.Header.Get(HeaderScaleSetMaxCapacity)
 			c, err := strconv.Atoi(hc)
 			require.NoError(t, err)
 			assert.GreaterOrEqual(t, c, 0)
@@ -138,17 +137,17 @@ func TestGetMessage(t *testing.T) {
 			w.Header().Set("Content-Type", "text/plain")
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetMessage(ctx, server.URL, token, 0, -1)
 		require.Error(t, err)
 		// Ensure we don't send requests with negative capacity
-		assert.False(t, errors.Is(err, &scaleset.ActionsError{}))
+		assert.False(t, errors.Is(err, &ActionsError{}))
 
 		_, err = client.GetMessage(ctx, server.URL, token, 0, 0)
 		assert.Error(t, err)
-		var expectedErr *scaleset.ActionsError
+		var expectedErr *ActionsError
 		assert.ErrorAs(t, err, &expectedErr)
 		assert.Equal(t, http.StatusBadRequest, expectedErr.StatusCode)
 	})
@@ -156,13 +155,13 @@ func TestGetMessage(t *testing.T) {
 
 func TestDeleteMessage(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	token := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjI1MTYyMzkwMjJ9.tlrHslTmDkoqnc4Kk9ISoKoUNDfHo-kjlH-ByISBqzE"
-	runnerScaleSetMessage := &scaleset.RunnerScaleSetMessage{
+	runnerScaleSetMessage := &RunnerScaleSetMessage{
-		MessageId:   1,
+		MessageID:   1,
 		MessageType: "rssType",
 	}
 
@@ -171,10 +170,10 @@ func TestDeleteMessage(t *testing.T) {
 			w.WriteHeader(http.StatusNoContent)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		err = client.DeleteMessage(ctx, server.URL, token, runnerScaleSetMessage.MessageId)
+		err = client.DeleteMessage(ctx, server.URL, token, runnerScaleSetMessage.MessageID)
 		assert.Nil(t, err)
 	})
 
@@ -183,12 +182,12 @@ func TestDeleteMessage(t *testing.T) {
 			w.WriteHeader(http.StatusUnauthorized)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		err = client.DeleteMessage(ctx, server.URL, token, 0)
 		require.NotNil(t, err)
-		var expectedErr *scaleset.MessageQueueTokenExpiredError
+		var expectedErr *MessageQueueTokenExpiredError
 		assert.True(t, errors.As(err, &expectedErr))
 	})
 
@@ -198,12 +197,12 @@ func TestDeleteMessage(t *testing.T) {
 			w.Header().Set("Content-Type", "text/plain")
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		err = client.DeleteMessage(ctx, server.URL, token, runnerScaleSetMessage.MessageId)
+		err = client.DeleteMessage(ctx, server.URL, token, runnerScaleSetMessage.MessageID)
 		require.NotNil(t, err)
-		var expectedErr *scaleset.ActionsError
+		var expectedErr *ActionsError
 		assert.True(t, errors.As(err, &expectedErr))
 	},
 	)
@@ -216,21 +215,21 @@ func TestDeleteMessage(t *testing.T) {
 		}))
 
 		retryMax := 1
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(1*time.Nanosecond),
+			WithRetryWaitMax(1*time.Nanosecond),
 		)
 		require.NoError(t, err)
-		err = client.DeleteMessage(ctx, server.URL, token, runnerScaleSetMessage.MessageId)
+		err = client.DeleteMessage(ctx, server.URL, token, runnerScaleSetMessage.MessageID)
 		assert.NotNil(t, err)
 		expectedRetry := retryMax + 1
 		assert.Equalf(t, actualRetry, expectedRetry, "A retry was expected after the first request but got: %v", actualRetry)
 	})
 
 	t.Run("No message found", func(t *testing.T) {
-		want := (*scaleset.RunnerScaleSetMessage)(nil)
+		want := (*RunnerScaleSetMessage)(nil)
 		rsl, err := json.Marshal(want)
 		require.NoError(t, err)
 
@@ -238,11 +237,11 @@ func TestDeleteMessage(t *testing.T) {
 			w.Write(rsl)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		err = client.DeleteMessage(ctx, server.URL, token, runnerScaleSetMessage.MessageId+1)
+		err = client.DeleteMessage(ctx, server.URL, token, runnerScaleSetMessage.MessageID+1)
-		var expectedErr *scaleset.ActionsError
+		var expectedErr *ActionsError
 		require.True(t, errors.As(err, &expectedErr))
 	})
 }

client_runner_scale_set_session_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"context"
@@ -7,7 +7,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/actions/scaleset"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -17,26 +16,26 @@ const exampleRequestID = "5ddf2050-dae0-013c-9159-04421ad31b68"
 
 func TestCreateMessageSession(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	t.Run("CreateMessageSession unmarshals correctly", func(t *testing.T) {
 		owner := "foo"
-		runnerScaleSet := scaleset.RunnerScaleSet{
+		runnerScaleSet := RunnerScaleSet{
-			Id:            1,
+			ID:            1,
 			Name:          "ScaleSet",
 			CreatedOn:     time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC),
-			RunnerSetting: scaleset.RunnerSetting{},
+			RunnerSetting: RunnerSetting{},
 		}
 
-		want := &scaleset.RunnerScaleSetSession{
+		want := &RunnerScaleSetSession{
 			OwnerName: "foo",
-			RunnerScaleSet: &scaleset.RunnerScaleSet{
+			RunnerScaleSet: &RunnerScaleSet{
-				Id:   1,
+				ID:   1,
 				Name: "ScaleSet",
 			},
-			MessageQueueUrl:         "http://fake.scaleset.github.com/123",
+			MessageQueueURL:         "http://fake.github.com/123",
 			MessageQueueAccessToken: "fake.jwt.here",
 		}
 
@@ -47,33 +46,33 @@ func TestCreateMessageSession(t *testing.T) {
 						"id": 1,
 						"name": "ScaleSet"
 					},
-					"messageQueueUrl": "http://fake.scaleset.github.com/123",
+					"messageQueueUrl": "http://fake.github.com/123",
 					"messageQueueAccessToken": "fake.jwt.here"
 				}`)
 			w.Write(resp)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		got, err := client.CreateMessageSession(ctx, runnerScaleSet.Id, owner)
+		got, err := client.CreateMessageSession(ctx, runnerScaleSet.ID, owner)
 		require.NoError(t, err)
 		assert.Equal(t, want, got)
 	})
 
 	t.Run("CreateMessageSession unmarshals errors into ActionsError", func(t *testing.T) {
 		owner := "foo"
-		runnerScaleSet := scaleset.RunnerScaleSet{
+		runnerScaleSet := RunnerScaleSet{
-			Id:            1,
+			ID:            1,
 			Name:          "ScaleSet",
 			CreatedOn:     time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC),
-			RunnerSetting: scaleset.RunnerSetting{},
+			RunnerSetting: RunnerSetting{},
 		}
 
-		want := &scaleset.ActionsError{
+		want := &ActionsError{
 			ActivityID: exampleRequestID,
 			StatusCode: http.StatusBadRequest,
-			Err: &scaleset.ActionsExceptionError{
+			Err: &ActionsExceptionError{
 				ExceptionName: "CSharpExceptionNameHere",
 				Message:       "could not do something",
 			},
@@ -81,19 +80,19 @@ func TestCreateMessageSession(t *testing.T) {
 
 		server := newActionsServer(t, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 			w.Header().Set("Content-Type", "application/json")
-			w.Header().Set(scaleset.HeaderActionsActivityID, exampleRequestID)
+			w.Header().Set(headerActionsActivityID, exampleRequestID)
 			w.WriteHeader(http.StatusBadRequest)
 			resp := []byte(`{"typeName": "CSharpExceptionNameHere","message": "could not do something"}`)
 			w.Write(resp)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		_, err = client.CreateMessageSession(ctx, runnerScaleSet.Id, owner)
+		_, err = client.CreateMessageSession(ctx, runnerScaleSet.ID, owner)
 		require.NotNil(t, err)
 
-		errorTypeForComparison := &scaleset.ActionsError{}
+		errorTypeForComparison := &ActionsError{}
 		assert.True(
 			t,
 			errors.As(err, &errorTypeForComparison),
@@ -106,11 +105,11 @@ func TestCreateMessageSession(t *testing.T) {
 
 	t.Run("CreateMessageSession call is retried the correct amount of times", func(t *testing.T) {
 		owner := "foo"
-		runnerScaleSet := scaleset.RunnerScaleSet{
+		runnerScaleSet := RunnerScaleSet{
-			Id:            1,
+			ID:            1,
 			Name:          "ScaleSet",
 			CreatedOn:     time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC),
-			RunnerSetting: scaleset.RunnerSetting{},
+			RunnerSetting: RunnerSetting{},
 		}
 
 		gotRetries := 0
@@ -124,15 +123,15 @@ func TestCreateMessageSession(t *testing.T) {
 
 		wantRetries := retryMax + 1
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(retryWaitMax),
+			WithRetryWaitMax(retryWaitMax),
 		)
 		require.NoError(t, err)
 
-		_, err = client.CreateMessageSession(ctx, runnerScaleSet.Id, owner)
+		_, err = client.CreateMessageSession(ctx, runnerScaleSet.ID, owner)
 		assert.NotNil(t, err)
 		assert.Equalf(t, gotRetries, wantRetries, "CreateMessageSession got unexpected retry count: got=%v, want=%v", gotRetries, wantRetries)
 	})
@@ -140,16 +139,16 @@ func TestCreateMessageSession(t *testing.T) {
 
 func TestDeleteMessageSession(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	t.Run("DeleteMessageSession call is retried the correct amount of times", func(t *testing.T) {
-		runnerScaleSet := scaleset.RunnerScaleSet{
+		runnerScaleSet := RunnerScaleSet{
-			Id:            1,
+			ID:            1,
 			Name:          "ScaleSet",
 			CreatedOn:     time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC),
-			RunnerSetting: scaleset.RunnerSetting{},
+			RunnerSetting: RunnerSetting{},
 		}
 
 		gotRetries := 0
@@ -163,33 +162,33 @@ func TestDeleteMessageSession(t *testing.T) {
 
 		wantRetries := retryMax + 1
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(retryWaitMax),
+			WithRetryWaitMax(retryWaitMax),
 		)
 		require.NoError(t, err)
 
-		sessionId := uuid.New()
+		sessionID := uuid.New()
 
-		err = client.DeleteMessageSession(ctx, runnerScaleSet.Id, &sessionId)
+		err = client.DeleteMessageSession(ctx, runnerScaleSet.ID, sessionID)
 		assert.NotNil(t, err)
 		assert.Equalf(t, gotRetries, wantRetries, "CreateMessageSession got unexpected retry count: got=%v, want=%v", gotRetries, wantRetries)
 	})
 }
 
 func TestRefreshMessageSession(t *testing.T) {
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	t.Run("RefreshMessageSession call is retried the correct amount of times", func(t *testing.T) {
-		runnerScaleSet := scaleset.RunnerScaleSet{
+		runnerScaleSet := RunnerScaleSet{
-			Id:            1,
+			ID:            1,
 			Name:          "ScaleSet",
 			CreatedOn:     time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC),
-			RunnerSetting: scaleset.RunnerSetting{},
+			RunnerSetting: RunnerSetting{},
 		}
 
 		gotRetries := 0
@@ -203,17 +202,17 @@ func TestRefreshMessageSession(t *testing.T) {
 
 		wantRetries := retryMax + 1
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(retryWaitMax),
+			WithRetryWaitMax(retryWaitMax),
 		)
 		require.NoError(t, err)
 
-		sessionId := uuid.New()
+		sessionID := uuid.New()
 
-		_, err = client.RefreshMessageSession(context.Background(), runnerScaleSet.Id, &sessionId)
+		_, err = client.RefreshMessageSession(context.Background(), runnerScaleSet.ID, sessionID)
 		assert.NotNil(t, err)
 		assert.Equalf(t, gotRetries, wantRetries, "CreateMessageSession got unexpected retry count: got=%v, want=%v", gotRetries, wantRetries)
 	})

client_runner_scale_set_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"context"
@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/actions/scaleset"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -18,12 +17,12 @@ import (
 
 func TestGetRunnerScaleSet(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	scaleSetName := "ScaleSet"
-	runnerScaleSet := scaleset.RunnerScaleSet{Id: 1, Name: scaleSetName}
+	runnerScaleSet := RunnerScaleSet{ID: 1, Name: scaleSetName}
 
 	t.Run("Get existing scale set", func(t *testing.T) {
 		want := &runnerScaleSet
@@ -32,7 +31,7 @@ func TestGetRunnerScaleSet(t *testing.T) {
 			w.Write(runnerScaleSetsResp)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GetRunnerScaleSet(ctx, 1, scaleSetName)
@@ -48,7 +47,7 @@ func TestGetRunnerScaleSet(t *testing.T) {
 			url = *r.URL
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetRunnerScaleSet(ctx, 1, scaleSetName)
@@ -65,7 +64,7 @@ func TestGetRunnerScaleSet(t *testing.T) {
 			w.WriteHeader(http.StatusNotFound)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetRunnerScaleSet(ctx, 1, scaleSetName)
@@ -78,7 +77,7 @@ func TestGetRunnerScaleSet(t *testing.T) {
 			w.Header().Set("Content-Type", "text/plain")
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetRunnerScaleSet(ctx, 1, scaleSetName)
@@ -95,11 +94,11 @@ func TestGetRunnerScaleSet(t *testing.T) {
 		retryMax := 1
 		retryWaitMax := 1 * time.Microsecond
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(retryWaitMax),
+			WithRetryWaitMax(retryWaitMax),
 		)
 		require.NoError(t, err)
 
@@ -110,13 +109,13 @@ func TestGetRunnerScaleSet(t *testing.T) {
 	})
 
 	t.Run("RunnerScaleSet count is zero", func(t *testing.T) {
-		want := (*scaleset.RunnerScaleSet)(nil)
+		want := (*RunnerScaleSet)(nil)
 		runnerScaleSetsResp := []byte(`{"count":0,"value":[{"id":1,"name":"ScaleSet"}]}`)
 		server := newActionsServer(t, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 			w.Write(runnerScaleSetsResp)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GetRunnerScaleSet(ctx, 1, scaleSetName)
@@ -126,18 +125,18 @@ func TestGetRunnerScaleSet(t *testing.T) {
 
 	t.Run("Multiple runner scale sets found", func(t *testing.T) {
 		reqID := uuid.NewString()
-		wantErr := &scaleset.ActionsError{
+		wantErr := &ActionsError{
 			StatusCode: http.StatusOK,
 			ActivityID: reqID,
 			Err:        fmt.Errorf("multiple runner scale sets found with name %q", scaleSetName),
 		}
 		runnerScaleSetsResp := []byte(`{"count":2,"value":[{"id":1,"name":"ScaleSet"}]}`)
 		server := newActionsServer(t, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-			w.Header().Set(scaleset.HeaderActionsActivityID, reqID)
+			w.Header().Set(headerActionsActivityID, reqID)
 			w.Write(runnerScaleSetsResp)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.GetRunnerScaleSet(ctx, 1, scaleSetName)
@@ -146,14 +145,14 @@ func TestGetRunnerScaleSet(t *testing.T) {
 	})
 }
 
-func TestGetRunnerScaleSetById(t *testing.T) {
+func TestGetRunnerScaleSetByID(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	scaleSetCreationDateTime := time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC)
-	runnerScaleSet := scaleset.RunnerScaleSet{Id: 1, Name: "ScaleSet", CreatedOn: scaleSetCreationDateTime, RunnerSetting: scaleset.RunnerSetting{}}
+	runnerScaleSet := RunnerScaleSet{ID: 1, Name: "ScaleSet", CreatedOn: scaleSetCreationDateTime, RunnerSetting: RunnerSetting{}}
 
 	t.Run("Get existing scale set by Id", func(t *testing.T) {
 		want := &runnerScaleSet
@@ -163,15 +162,15 @@ func TestGetRunnerScaleSetById(t *testing.T) {
 			w.Write(rsl)
 		}))
 
-		client, err := scaleset.NewClient(sservere.configURLForOrg("my-org"), auth)
+		client, err := NewClient(sservere.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		got, err := client.GetRunnerScaleSetById(ctx, runnerScaleSet.Id)
+		got, err := client.GetRunnerScaleSetByID(ctx, runnerScaleSet.ID)
 		require.NoError(t, err)
 		assert.Equal(t, want, got)
 	})
 
-	t.Run("GetRunnerScaleSetById calls correct url", func(t *testing.T) {
+	t.Run("GetRunnerScaleSetByID calls correct url", func(t *testing.T) {
 		rsl, err := json.Marshal(&runnerScaleSet)
 		require.NoError(t, err)
 
@@ -181,13 +180,13 @@ func TestGetRunnerScaleSetById(t *testing.T) {
 			url = *r.URL
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		_, err = client.GetRunnerScaleSetById(ctx, runnerScaleSet.Id)
+		_, err = client.GetRunnerScaleSetByID(ctx, runnerScaleSet.ID)
 		require.NoError(t, err)
 
-		expectedPath := fmt.Sprintf("/tenant/123/_apis/runtime/runnerscalesets/%d", runnerScaleSet.Id)
+		expectedPath := fmt.Sprintf("/tenant/123/_apis/runtime/runnerscalesets/%d", runnerScaleSet.ID)
 		assert.Equal(t, expectedPath, url.Path)
 		assert.Equal(t, "6.0-preview", url.Query().Get("api-version"))
 	})
@@ -197,10 +196,10 @@ func TestGetRunnerScaleSetById(t *testing.T) {
 			w.WriteHeader(http.StatusNotFound)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		_, err = client.GetRunnerScaleSetById(ctx, runnerScaleSet.Id)
+		_, err = client.GetRunnerScaleSetByID(ctx, runnerScaleSet.ID)
 		assert.NotNil(t, err)
 	})
 
@@ -210,10 +209,10 @@ func TestGetRunnerScaleSetById(t *testing.T) {
 			w.Header().Set("Content-Type", "text/plain")
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		_, err = client.GetRunnerScaleSetById(ctx, runnerScaleSet.Id)
+		_, err = client.GetRunnerScaleSetByID(ctx, runnerScaleSet.ID)
 		assert.NotNil(t, err)
 	})
 
@@ -226,32 +225,32 @@ func TestGetRunnerScaleSetById(t *testing.T) {
 
 		retryMax := 1
 		retryWaitMax := 1 * time.Microsecond
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(retryWaitMax),
+			WithRetryWaitMax(retryWaitMax),
 		)
 		require.NoError(t, err)
 
-		_, err = client.GetRunnerScaleSetById(ctx, runnerScaleSet.Id)
+		_, err = client.GetRunnerScaleSetByID(ctx, runnerScaleSet.ID)
 		require.NotNil(t, err)
 		expectedRetry := retryMax + 1
 		assert.Equalf(t, actualRetry, expectedRetry, "A retry was expected after the first request but got: %v", actualRetry)
 	})
 
 	t.Run("No RunnerScaleSet found", func(t *testing.T) {
-		want := (*scaleset.RunnerScaleSet)(nil)
+		want := (*RunnerScaleSet)(nil)
 		rsl, err := json.Marshal(want)
 		require.NoError(t, err)
 		server := newActionsServer(t, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 			w.Write(rsl)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		got, err := client.GetRunnerScaleSetById(ctx, runnerScaleSet.Id)
+		got, err := client.GetRunnerScaleSetByID(ctx, runnerScaleSet.ID)
 		require.NoError(t, err)
 		assert.Equal(t, want, got)
 	})
@@ -259,12 +258,12 @@ func TestGetRunnerScaleSetById(t *testing.T) {
 
 func TestCreateRunnerScaleSet(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	scaleSetCreationDateTime := time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC)
-	runnerScaleSet := scaleset.RunnerScaleSet{Id: 1, Name: "ScaleSet", CreatedOn: scaleSetCreationDateTime, RunnerSetting: scaleset.RunnerSetting{}}
+	runnerScaleSet := RunnerScaleSet{ID: 1, Name: "ScaleSet", CreatedOn: scaleSetCreationDateTime, RunnerSetting: RunnerSetting{}}
 
 	t.Run("Create runner scale set", func(t *testing.T) {
 		want := &runnerScaleSet
@@ -274,7 +273,7 @@ func TestCreateRunnerScaleSet(t *testing.T) {
 			w.Write(rsl)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.CreateRunnerScaleSet(ctx, &runnerScaleSet)
@@ -291,7 +290,7 @@ func TestCreateRunnerScaleSet(t *testing.T) {
 			url = *r.URL
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.CreateRunnerScaleSet(ctx, &runnerScaleSet)
@@ -308,12 +307,12 @@ func TestCreateRunnerScaleSet(t *testing.T) {
 			w.Header().Set("Content-Type", "text/plain")
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.CreateRunnerScaleSet(ctx, &runnerScaleSet)
 		require.NotNil(t, err)
-		var expectedErr *scaleset.ActionsError
+		var expectedErr *ActionsError
 		assert.True(t, errors.As(err, &expectedErr))
 	})
 
@@ -327,11 +326,11 @@ func TestCreateRunnerScaleSet(t *testing.T) {
 		retryMax := 1
 		retryWaitMax := 1 * time.Microsecond
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(retryWaitMax),
+			WithRetryWaitMax(retryWaitMax),
 		)
 		require.NoError(t, err)
 
@@ -344,12 +343,12 @@ func TestCreateRunnerScaleSet(t *testing.T) {
 
 func TestUpdateRunnerScaleSet(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	scaleSetCreationDateTime := time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC)
-	runnerScaleSet := scaleset.RunnerScaleSet{Id: 1, Name: "ScaleSet", RunnerGroupId: 1, RunnerGroupName: "group", CreatedOn: scaleSetCreationDateTime, RunnerSetting: scaleset.RunnerSetting{}}
+	runnerScaleSet := RunnerScaleSet{ID: 1, Name: "ScaleSet", RunnerGroupID: 1, RunnerGroupName: "group", CreatedOn: scaleSetCreationDateTime, RunnerSetting: RunnerSetting{}}
 
 	t.Run("Update runner scale set", func(t *testing.T) {
 		want := &runnerScaleSet
@@ -359,10 +358,10 @@ func TestUpdateRunnerScaleSet(t *testing.T) {
 			w.Write(rsl)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
-		got, err := client.UpdateRunnerScaleSet(ctx, 1, &scaleset.RunnerScaleSet{RunnerGroupId: 1})
+		got, err := client.UpdateRunnerScaleSet(ctx, 1, &RunnerScaleSet{RunnerGroupID: 1})
 		require.NoError(t, err)
 		assert.Equal(t, want, got)
 	})
@@ -379,7 +378,7 @@ func TestUpdateRunnerScaleSet(t *testing.T) {
 			w.Write(rsl)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		_, err = client.UpdateRunnerScaleSet(ctx, 1, &runnerScaleSet)
@@ -389,7 +388,7 @@ func TestUpdateRunnerScaleSet(t *testing.T) {
 
 func TestDeleteRunnerScaleSet(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
@@ -400,7 +399,7 @@ func TestDeleteRunnerScaleSet(t *testing.T) {
 			w.WriteHeader(http.StatusNoContent)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		err = client.DeleteRunnerScaleSet(ctx, 10)
@@ -415,7 +414,7 @@ func TestDeleteRunnerScaleSet(t *testing.T) {
 			w.Write([]byte(`{"message": "test error"}`))
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		err = client.DeleteRunnerScaleSet(ctx, 10)

client_runner_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"context"
@@ -6,21 +6,20 @@ import (
 	"testing"
 	"time"
 
-	"github.com/actions/scaleset"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestGetRunner(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	t.Run("Get Runner", func(t *testing.T) {
 		var runnerID int64 = 1
-		want := &scaleset.RunnerReference{
+		want := &RunnerReference{
-			Id:   int(runnerID),
+			ID:   int(runnerID),
 			Name: "self-hosted-ubuntu",
 		}
 		response := []byte(`{"id": 1, "name": "self-hosted-ubuntu"}`)
@@ -29,7 +28,7 @@ func TestGetRunner(t *testing.T) {
 			w.Write(response)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GetRunner(ctx, runnerID)
@@ -50,7 +49,7 @@ func TestGetRunner(t *testing.T) {
 			actualRetry++
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth, scaleset.WithRetryMax(retryMax), scaleset.WithRetryWaitMax(retryWaitMax))
+		client, err := NewClient(server.configURLForOrg("my-org"), auth, WithRetryMax(retryMax), WithRetryWaitMax(retryWaitMax))
 		require.NoError(t, err)
 
 		_, err = client.GetRunner(ctx, runnerID)
@@ -61,15 +60,15 @@ func TestGetRunner(t *testing.T) {
 
 func TestGetRunnerByName(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	t.Run("Get Runner by Name", func(t *testing.T) {
 		var runnerID int64 = 1
 		var runnerName = "self-hosted-ubuntu"
-		want := &scaleset.RunnerReference{
+		want := &RunnerReference{
-			Id:   int(runnerID),
+			ID:   int(runnerID),
 			Name: runnerName,
 		}
 		response := []byte(`{"count": 1, "value": [{"id": 1, "name": "self-hosted-ubuntu"}]}`)
@@ -78,7 +77,7 @@ func TestGetRunnerByName(t *testing.T) {
 			w.Write(response)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GetRunnerByName(ctx, runnerName)
@@ -94,7 +93,7 @@ func TestGetRunnerByName(t *testing.T) {
 			w.Write(response)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GetRunnerByName(ctx, runnerName)
@@ -116,7 +115,7 @@ func TestGetRunnerByName(t *testing.T) {
 			actualRetry++
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth, scaleset.WithRetryMax(retryMax), scaleset.WithRetryWaitMax(retryWaitMax))
+		client, err := NewClient(server.configURLForOrg("my-org"), auth, WithRetryMax(retryMax), WithRetryWaitMax(retryWaitMax))
 		require.NoError(t, err)
 
 		_, err = client.GetRunnerByName(ctx, runnerName)
@@ -127,7 +126,7 @@ func TestGetRunnerByName(t *testing.T) {
 
 func TestDeleteRunner(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
@@ -138,7 +137,7 @@ func TestDeleteRunner(t *testing.T) {
 			w.WriteHeader(http.StatusNoContent)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		err = client.RemoveRunner(ctx, runnerID)
@@ -159,11 +158,11 @@ func TestDeleteRunner(t *testing.T) {
 			actualRetry++
 		}))
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			server.configURLForOrg("my-org"),
 			auth,
-			scaleset.WithRetryMax(retryMax),
+			WithRetryMax(retryMax),
-			scaleset.WithRetryWaitMax(retryWaitMax),
+			WithRetryWaitMax(retryWaitMax),
 		)
 		require.NoError(t, err)
 
@@ -175,14 +174,14 @@ func TestDeleteRunner(t *testing.T) {
 
 func TestGetRunnerGroupByName(t *testing.T) {
 	ctx := context.Background()
-	auth := &scaleset.ActionsAuth{
+	auth := &ActionsAuth{
 		Token: "token",
 	}
 
 	t.Run("Get RunnerGroup by Name", func(t *testing.T) {
 		var runnerGroupID int64 = 1
 		var runnerGroupName = "test-runner-group"
-		want := &scaleset.RunnerGroup{
+		want := &RunnerGroup{
 			ID:   runnerGroupID,
 			Name: runnerGroupName,
 		}
@@ -192,7 +191,7 @@ func TestGetRunnerGroupByName(t *testing.T) {
 			w.Write(response)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GetRunnerGroupByName(ctx, runnerGroupName)
@@ -208,7 +207,7 @@ func TestGetRunnerGroupByName(t *testing.T) {
 			w.Write(response)
 		}))
 
-		client, err := scaleset.NewClient(server.configURLForOrg("my-org"), auth)
+		client, err := NewClient(server.configURLForOrg("my-org"), auth)
 		require.NoError(t, err)
 
 		got, err := client.GetRunnerGroupByName(ctx, runnerGroupName)

client_tls_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"context"
@@ -14,7 +14,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/actions/scaleset"
 	"github.com/golang-jwt/jwt/v4"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -62,10 +61,10 @@ func TestServerWithSelfSignedCertificates(t *testing.T) {
 		u = server.URL
 		configURL := server.URL + "/my-org"
 
-		auth := &scaleset.ActionsAuth{
+		auth := &ActionsAuth{
 			Token: "token",
 		}
-		client, err := scaleset.NewClient(configURL, auth)
+		client, err := NewClient(configURL, auth)
 		require.NoError(t, err)
 		require.NotNil(t, client)
 
@@ -93,7 +92,7 @@ func TestServerWithSelfSignedCertificates(t *testing.T) {
 		u = server.URL
 		configURL := server.URL + "/my-org"
 
-		auth := &scaleset.ActionsAuth{
+		auth := &ActionsAuth{
 			Token: "token",
 		}
 
@@ -103,10 +102,10 @@ func TestServerWithSelfSignedCertificates(t *testing.T) {
 		pool := x509.NewCertPool()
 		require.True(t, pool.AppendCertsFromPEM(cert))
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			configURL,
 			auth,
-			scaleset.WithRootCAs(pool),
+			WithRootCAs(pool),
 		)
 		require.NoError(t, err)
 		assert.NotNil(t, client)
@@ -125,7 +124,7 @@ func TestServerWithSelfSignedCertificates(t *testing.T) {
 		u = server.URL
 		configURL := server.URL + "/my-org"
 
-		auth := &scaleset.ActionsAuth{
+		auth := &ActionsAuth{
 			Token: "token",
 		}
 
@@ -135,11 +134,11 @@ func TestServerWithSelfSignedCertificates(t *testing.T) {
 		pool := x509.NewCertPool()
 		require.True(t, pool.AppendCertsFromPEM(cert))
 
-		client, err := scaleset.NewClient(
+		client, err := NewClient(
 			configURL,
 			auth,
-			scaleset.WithRootCAs(pool),
+			WithRootCAs(pool),
-			scaleset.WithRetryMax(0),
+			WithRetryMax(0),
 		)
 		require.NoError(t, err)
 		require.NotNil(t, client)
@@ -152,11 +151,11 @@ func TestServerWithSelfSignedCertificates(t *testing.T) {
 		server := startNewTLSTestServer(t, certPath, keyPath, http.HandlerFunc(h))
 		configURL := server.URL + "/my-org"
 
-		auth := &scaleset.ActionsAuth{
+		auth := &ActionsAuth{
 			Token: "token",
 		}
 
-		client, err := scaleset.NewClient(configURL, auth, scaleset.WithoutTLSVerify())
+		client, err := NewClient(configURL, auth, WithoutTLSVerify())
 		require.NoError(t, err)
 		assert.NotNil(t, client)
 	})

config_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"errors"
@@ -7,7 +7,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/actions/scaleset"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -16,12 +15,12 @@ func TestGitHubConfig(t *testing.T) {
 	t.Run("when given a valid URL", func(t *testing.T) {
 		tests := []struct {
 			configURL string
-			expected  *scaleset.GitHubConfig
+			expected  *GitHubConfig
 		}{
 			{
 				configURL: "https://github.com/org/repo",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeRepository,
+					Scope:        GitHubScopeRepository,
 					Enterprise:   "",
 					Organization: "org",
 					Repository:   "repo",
@@ -30,8 +29,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://github.com/org/repo/",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeRepository,
+					Scope:        GitHubScopeRepository,
 					Enterprise:   "",
 					Organization: "org",
 					Repository:   "repo",
@@ -40,8 +39,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://github.com/org",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeOrganization,
+					Scope:        GitHubScopeOrganization,
 					Enterprise:   "",
 					Organization: "org",
 					Repository:   "",
@@ -50,8 +49,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://github.com/enterprises/my-enterprise",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeEnterprise,
+					Scope:        GitHubScopeEnterprise,
 					Enterprise:   "my-enterprise",
 					Organization: "",
 					Repository:   "",
@@ -60,8 +59,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://github.com/enterprises/my-enterprise/",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeEnterprise,
+					Scope:        GitHubScopeEnterprise,
 					Enterprise:   "my-enterprise",
 					Organization: "",
 					Repository:   "",
@@ -70,8 +69,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://www.github.com/org",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeOrganization,
+					Scope:        GitHubScopeOrganization,
 					Enterprise:   "",
 					Organization: "org",
 					Repository:   "",
@@ -80,8 +79,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://www.github.com/org/",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeOrganization,
+					Scope:        GitHubScopeOrganization,
 					Enterprise:   "",
 					Organization: "org",
 					Repository:   "",
@@ -90,8 +89,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://github.localhost/org",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeOrganization,
+					Scope:        GitHubScopeOrganization,
 					Enterprise:   "",
 					Organization: "org",
 					Repository:   "",
@@ -100,8 +99,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://my-ghes.com/org",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeOrganization,
+					Scope:        GitHubScopeOrganization,
 					Enterprise:   "",
 					Organization: "org",
 					Repository:   "",
@@ -110,8 +109,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://my-ghes.com/org/",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeOrganization,
+					Scope:        GitHubScopeOrganization,
 					Enterprise:   "",
 					Organization: "org",
 					Repository:   "",
@@ -120,8 +119,8 @@ func TestGitHubConfig(t *testing.T) {
 			},
 			{
 				configURL: "https://my-ghes.ghe.com/org/",
-				expected: &scaleset.GitHubConfig{
+				expected: &GitHubConfig{
-					Scope:        scaleset.GitHubScopeOrganization,
+					Scope:        GitHubScopeOrganization,
 					Enterprise:   "",
 					Organization: "org",
 					Repository:   "",
@@ -136,7 +135,7 @@ func TestGitHubConfig(t *testing.T) {
 				require.NoError(t, err)
 				test.expected.ConfigURL = parsedURL
 
-				cfg, err := scaleset.ParseGitHubConfigFromURL(test.configURL)
+				cfg, err := ParseGitHubConfigFromURL(test.configURL)
 				require.NoError(t, err)
 				assert.Equal(t, test.expected, cfg)
 			})
@@ -151,16 +150,16 @@ func TestGitHubConfig(t *testing.T) {
 		}
 
 		for _, u := range invalidURLs {
-			_, err := scaleset.ParseGitHubConfigFromURL(u)
+			_, err := ParseGitHubConfigFromURL(u)
 			require.Error(t, err)
-			assert.True(t, errors.Is(err, scaleset.ErrInvalidGitHubConfigURL))
+			assert.True(t, errors.Is(err, ErrInvalidGitHubConfigURL))
 		}
 	})
 }
 
 func TestGitHubConfig_GitHubAPIURL(t *testing.T) {
 	t.Run("when hosted", func(t *testing.T) {
-		config, err := scaleset.ParseGitHubConfigFromURL("https://github.com/org/repo")
+		config, err := ParseGitHubConfigFromURL("https://github.com/org/repo")
 		require.NoError(t, err)
 		assert.True(t, config.IsHosted)
 
@@ -168,7 +167,7 @@ func TestGitHubConfig_GitHubAPIURL(t *testing.T) {
 		assert.Equal(t, "https://api.github.com/some/path", result.String())
 	})
 	t.Run("when hosted with ghe.com", func(t *testing.T) {
-		config, err := scaleset.ParseGitHubConfigFromURL("https://github.ghe.com/org/repo")
+		config, err := ParseGitHubConfigFromURL("https://github.ghe.com/org/repo")
 		require.NoError(t, err)
 		assert.True(t, config.IsHosted)
 
@@ -176,7 +175,7 @@ func TestGitHubConfig_GitHubAPIURL(t *testing.T) {
 		assert.Equal(t, "https://api.github.ghe.com/some/path", result.String())
 	})
 	t.Run("when not hosted", func(t *testing.T) {
-		config, err := scaleset.ParseGitHubConfigFromURL("https://ghes.com/org/repo")
+		config, err := ParseGitHubConfigFromURL("https://ghes.com/org/repo")
 		require.NoError(t, err)
 		assert.False(t, config.IsHosted)
 
@@ -186,7 +185,7 @@ func TestGitHubConfig_GitHubAPIURL(t *testing.T) {
 	t.Run("when not hosted with ghe.com", func(t *testing.T) {
 		os.Setenv("GITHUB_ACTIONS_FORCE_GHES", "1")
 		defer os.Unsetenv("GITHUB_ACTIONS_FORCE_GHES")
-		config, err := scaleset.ParseGitHubConfigFromURL("https://test.ghe.com/org/repo")
+		config, err := ParseGitHubConfigFromURL("https://test.ghe.com/org/repo")
 		require.NoError(t, err)
 		assert.False(t, config.IsHosted)
 

error.go

@@ -11,8 +11,8 @@ import (
 
 // Header names for request IDs
 const (
-	HeaderActionsActivityID = "ActivityId"
+	headerActionsActivityID = "ActivityId"
-	HeaderGitHubRequestID   = "X-GitHub-Request-Id"
+	headerGitHubRequestID   = "X-GitHub-Request-Id"
 )
 
 type GitHubAPIError struct {
@@ -59,20 +59,19 @@ func (e *ActionsExceptionError) Error() string {
 	return fmt.Sprintf("%s: %s", e.ExceptionName, e.Message)
 }
 
-func ParseActionsErrorFromResponse(response *http.Response) error {
+func parseActionsErrorFromResponse(response *http.Response) error {
 	if response.ContentLength == 0 {
 		return &ActionsError{
-			ActivityID: response.Header.Get(HeaderActionsActivityID),
+			ActivityID: response.Header.Get(headerActionsActivityID),
 			StatusCode: response.StatusCode,
 			Err:        errors.New("unknown exception"),
 		}
 	}
 
-	defer response.Body.Close()
 	body, err := io.ReadAll(response.Body)
 	if err != nil {
 		return &ActionsError{
-			ActivityID: response.Header.Get(HeaderActionsActivityID),
+			ActivityID: response.Header.Get(headerActionsActivityID),
 			StatusCode: response.StatusCode,
 			Err:        err,
 		}
@@ -83,7 +82,7 @@ func ParseActionsErrorFromResponse(response *http.Response) error {
 	if ok && len(contentType) > 0 && strings.Contains(contentType[0], "text/plain") {
 		message := string(body)
 		return &ActionsError{
-			ActivityID: response.Header.Get(HeaderActionsActivityID),
+			ActivityID: response.Header.Get(headerActionsActivityID),
 			StatusCode: response.StatusCode,
 			Err:        errors.New(message),
 		}
@@ -92,14 +91,14 @@ func ParseActionsErrorFromResponse(response *http.Response) error {
 	var exception ActionsExceptionError
 	if err := json.Unmarshal(body, &exception); err != nil {
 		return &ActionsError{
-			ActivityID: response.Header.Get(HeaderActionsActivityID),
+			ActivityID: response.Header.Get(headerActionsActivityID),
 			StatusCode: response.StatusCode,
 			Err:        err,
 		}
 	}
 
 	return &ActionsError{
-		ActivityID: response.Header.Get(HeaderActionsActivityID),
+		ActivityID: response.Header.Get(headerActionsActivityID),
 		StatusCode: response.StatusCode,
 		Err:        &exception,
 	}

errors_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"errors"
@@ -7,14 +7,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/actions/scaleset"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestActionsError(t *testing.T) {
 	t.Run("contains the status code, activity ID, and error", func(t *testing.T) {
-		err := &scaleset.ActionsError{
+		err := &ActionsError{
 			ActivityID: "activity-id",
 			StatusCode: 404,
 			Err:        errors.New("example error description"),
@@ -27,10 +26,10 @@ func TestActionsError(t *testing.T) {
 	})
 
 	t.Run("unwraps the error", func(t *testing.T) {
-		err := &scaleset.ActionsError{
+		err := &ActionsError{
 			ActivityID: "activity-id",
 			StatusCode: 404,
-			Err: &scaleset.ActionsExceptionError{
+			Err: &ActionsExceptionError{
 				ExceptionName: "exception-name",
 				Message:       "example error message",
 			},
@@ -40,23 +39,23 @@ func TestActionsError(t *testing.T) {
 	})
 
 	t.Run("is exception is ok", func(t *testing.T) {
-		err := &scaleset.ActionsError{
+		err := &ActionsError{
 			ActivityID: "activity-id",
 			StatusCode: 404,
-			Err: &scaleset.ActionsExceptionError{
+			Err: &ActionsExceptionError{
 				ExceptionName: "exception-name",
 				Message:       "example error message",
 			},
 		}
 
-		var exception *scaleset.ActionsExceptionError
+		var exception *ActionsExceptionError
 		assert.True(t, errors.As(err, &exception))
 
 		assert.True(t, err.IsException("exception-name"))
 	})
 
 	t.Run("is exception is not ok", func(t *testing.T) {
-		tt := map[string]*scaleset.ActionsError{
+		tt := map[string]*ActionsError{
 			"not an exception": {
 				ActivityID: "activity-id",
 				StatusCode: 404,
@@ -65,7 +64,7 @@ func TestActionsError(t *testing.T) {
 			"not target exception": {
 				ActivityID: "activity-id",
 				StatusCode: 404,
-				Err: &scaleset.ActionsExceptionError{
+				Err: &ActionsExceptionError{
 					ExceptionName: "exception-name",
 					Message:       "example error message",
 				},
@@ -83,7 +82,7 @@ func TestActionsError(t *testing.T) {
 
 func TestActionsExceptionError(t *testing.T) {
 	t.Run("contains the exception name and message", func(t *testing.T) {
-		err := &scaleset.ActionsExceptionError{
+		err := &ActionsExceptionError{
 			ExceptionName: "exception-name",
 			Message:       "example error message",
 		}
@@ -96,7 +95,7 @@ func TestActionsExceptionError(t *testing.T) {
 
 func TestGitHubAPIError(t *testing.T) {
 	t.Run("contains the status code, request ID, and error", func(t *testing.T) {
-		err := &scaleset.GitHubAPIError{
+		err := &GitHubAPIError{
 			StatusCode: 404,
 			RequestID:  "request-id",
 			Err:        errors.New("example error description"),
@@ -109,7 +108,7 @@ func TestGitHubAPIError(t *testing.T) {
 	})
 
 	t.Run("unwraps the error", func(t *testing.T) {
-		err := &scaleset.GitHubAPIError{
+		err := &GitHubAPIError{
 			StatusCode: 404,
 			RequestID:  "request-id",
 			Err:        errors.New("example error description"),
@@ -124,16 +123,16 @@ func ParseActionsErrorFromResponse(t *testing.T) {
 		response := &http.Response{
 			ContentLength: 0,
 			Header: http.Header{
-				scaleset.HeaderActionsActivityID: []string{"activity-id"},
+				headerActionsActivityID: []string{"activity-id"},
 			},
 			StatusCode: 404,
 		}
 
-		err := scaleset.ParseActionsErrorFromResponse(response)
+		err := parseActionsErrorFromResponse(response)
 		require.Error(t, err)
-		assert.Equal(t, err.(*scaleset.ActionsError).ActivityID, "activity-id")
+		assert.Equal(t, err.(*ActionsError).ActivityID, "activity-id")
-		assert.Equal(t, err.(*scaleset.ActionsError).StatusCode, 404)
+		assert.Equal(t, err.(*ActionsError).StatusCode, 404)
-		assert.Equal(t, err.(*scaleset.ActionsError).Err.Error(), "unknown exception")
+		assert.Equal(t, err.(*ActionsError).Err.Error(), "unknown exception")
 	})
 
 	t.Run("contains text plain error", func(t *testing.T) {
@@ -141,16 +140,16 @@ func ParseActionsErrorFromResponse(t *testing.T) {
 		response := &http.Response{
 			ContentLength: int64(len(errorMessage)),
 			Header: http.Header{
-				scaleset.HeaderActionsActivityID: []string{"activity-id"},
+				headerActionsActivityID: []string{"activity-id"},
-				"Content-Type":                   []string{"text/plain"},
+				"Content-Type":          []string{"text/plain"},
 			},
 			StatusCode: 404,
 			Body:       io.NopCloser(strings.NewReader(errorMessage)),
 		}
 
-		err := scaleset.ParseActionsErrorFromResponse(response)
+		err := parseActionsErrorFromResponse(response)
 		require.Error(t, err)
-		var actionsError *scaleset.ActionsError
+		var actionsError *ActionsError
 		assert.ErrorAs(t, err, &actionsError)
 		assert.Equal(t, actionsError.ActivityID, "activity-id")
 		assert.Equal(t, actionsError.StatusCode, 404)
@@ -162,21 +161,21 @@ func ParseActionsErrorFromResponse(t *testing.T) {
 		response := &http.Response{
 			ContentLength: int64(len(errorMessage)),
 			Header: http.Header{
-				scaleset.HeaderActionsActivityID: []string{"activity-id"},
+				headerActionsActivityID: []string{"activity-id"},
-				"Content-Type":                   []string{"application/json"},
+				"Content-Type":          []string{"application/json"},
 			},
 			StatusCode: 404,
 			Body:       io.NopCloser(strings.NewReader(errorMessage)),
 		}
 
-		err := scaleset.ParseActionsErrorFromResponse(response)
+		err := parseActionsErrorFromResponse(response)
 		require.Error(t, err)
-		var actionsError *scaleset.ActionsError
+		var actionsError *ActionsError
 		assert.ErrorAs(t, err, &actionsError)
 		assert.Equal(t, actionsError.ActivityID, "activity-id")
 		assert.Equal(t, actionsError.StatusCode, 404)
 
-		inner, ok := actionsError.Err.(*scaleset.ActionsExceptionError)
+		inner, ok := actionsError.Err.(*ActionsExceptionError)
 		require.True(t, ok)
 		assert.Equal(t, inner.ExceptionName, "exception-name")
 		assert.Equal(t, inner.Message, "example error message")
@@ -187,17 +186,17 @@ func ParseActionsErrorFromResponse(t *testing.T) {
 		response := &http.Response{
 			ContentLength: int64(len(errorMessage)),
 			Header: http.Header{
-				scaleset.HeaderActionsActivityID: []string{"activity-id"},
+				headerActionsActivityID: []string{"activity-id"},
-				"Content-Type":                   []string{"application/json"},
+				"Content-Type":          []string{"application/json"},
 			},
 			StatusCode: 404,
 			Body:       io.NopCloser(strings.NewReader(errorMessage)),
 		}
 
-		err := scaleset.ParseActionsErrorFromResponse(response)
+		err := parseActionsErrorFromResponse(response)
 		require.Error(t, err)
 
-		var actionsExceptionError *scaleset.ActionsExceptionError
+		var actionsExceptionError *ActionsExceptionError
 		assert.ErrorAs(t, err, &actionsExceptionError)
 
 		assert.Equal(t, actionsExceptionError.ExceptionName, "exception-name")

github_api_request_test.go

@@ -1,4 +1,4 @@
-package scaleset_test
+package scaleset
 
 import (
 	"context"
@@ -10,13 +10,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/actions/scaleset"
 	"github.com/actions/scaleset/testserver"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-var testUserAgent = scaleset.UserAgentInfo{
+var testUserAgent = UserAgentInfo{
 	Version:    "test",
 	CommitSHA:  "test",
 	ScaleSetID: 1,
@@ -59,32 +58,32 @@ func TestNewGitHubAPIRequest(t *testing.T) {
 		}
 
 		for _, scenario := range scenarios {
-			client, err := scaleset.NewClient(scenario.configURL, nil)
+			client, err := NewClient(scenario.configURL, nil)
 			require.NoError(t, err)
 
-			req, err := client.NewGitHubAPIRequest(ctx, http.MethodGet, scenario.path, nil)
+			req, err := client.newGitHubAPIRequest(ctx, http.MethodGet, scenario.path, nil)
 			require.NoError(t, err)
 			assert.Equal(t, scenario.expected, req.URL.String())
 		}
 	})
 
 	t.Run("sets user agent header if present", func(t *testing.T) {
-		client, err := scaleset.NewClient("http://localhost/my-org", nil)
+		client, err := NewClient("http://localhost/my-org", nil)
 		require.NoError(t, err)
 
 		client.SetUserAgent(testUserAgent)
 
-		req, err := client.NewGitHubAPIRequest(ctx, http.MethodGet, "/app/installations/123/access_tokens", nil)
+		req, err := client.newGitHubAPIRequest(ctx, http.MethodGet, "/app/installations/123/access_tokens", nil)
 		require.NoError(t, err)
 
 		assert.Equal(t, testUserAgent.String(), req.Header.Get("User-Agent"))
 	})
 
 	t.Run("sets the body we pass", func(t *testing.T) {
-		client, err := scaleset.NewClient("http://localhost/my-org", nil)
+		client, err := NewClient("http://localhost/my-org", nil)
 		require.NoError(t, err)
 
-		req, err := client.NewGitHubAPIRequest(
+		req, err := client.newGitHubAPIRequest(
 			ctx,
 			http.MethodGet,
 			"/app/installations/123/access_tokens",
@@ -100,17 +99,17 @@ func TestNewGitHubAPIRequest(t *testing.T) {
 
 func TestNewActionsServiceRequest(t *testing.T) {
 	ctx := context.Background()
-	defaultCreds := &scaleset.ActionsAuth{Token: "token"}
+	defaultCreds := &ActionsAuth{Token: "token"}
 
 	t.Run("manages authentication", func(t *testing.T) {
 		t.Run("client is brand new", func(t *testing.T) {
 			token := defaultActionsToken(t)
 			server := testserver.New(t, nil, testserver.WithActionsToken(token))
 
-			client, err := scaleset.NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
+			client, err := NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
 			require.NoError(t, err)
 
-			req, err := client.NewActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
+			req, err := client.newActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
 			require.NoError(t, err)
 
 			assert.Equal(t, "Bearer "+token, req.Header.Get("Authorization"))
@@ -120,12 +119,12 @@ func TestNewActionsServiceRequest(t *testing.T) {
 			newToken := defaultActionsToken(t)
 			server := testserver.New(t, nil, testserver.WithActionsToken(newToken))
 
-			client, err := scaleset.NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
+			client, err := NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
 			require.NoError(t, err)
-			client.ActionsServiceAdminToken = "expiring-token"
+			client.actionsServiceAdminToken = "expiring-token"
-			client.ActionsServiceAdminTokenExpiresAt = time.Now().Add(59 * time.Second)
+			client.actionsServiceAdminTokenExpiresAt = time.Now().Add(59 * time.Second)
 
-			req, err := client.NewActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
+			req, err := client.newActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
 			require.NoError(t, err)
 
 			assert.Equal(t, "Bearer "+newToken, req.Header.Get("Authorization"))
@@ -146,17 +145,17 @@ func TestNewActionsServiceRequest(t *testing.T) {
 				testserver.WithActionsToken(newToken),
 				testserver.WithActionsRegistrationTokenHandler(unauthorizedHandler),
 			)
-			client, err := scaleset.NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
+			client, err := NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
 			require.NoError(t, err)
 			expiringToken := "expiring-token"
 			expiresAt := time.Now().Add(59 * time.Second)
-			client.ActionsServiceAdminToken = expiringToken
+			client.actionsServiceAdminToken = expiringToken
-			client.ActionsServiceAdminTokenExpiresAt = expiresAt
+			client.actionsServiceAdminTokenExpiresAt = expiresAt
-			_, err = client.NewActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
+			_, err = client.newActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
 			require.Error(t, err)
 			assert.Contains(t, err.Error(), errMessage)
-			assert.Equal(t, client.ActionsServiceAdminToken, expiringToken)
+			assert.Equal(t, client.actionsServiceAdminToken, expiringToken)
-			assert.Equal(t, client.ActionsServiceAdminTokenExpiresAt, expiresAt)
+			assert.Equal(t, client.actionsServiceAdminTokenExpiresAt, expiresAt)
 		})
 
 		t.Run("admin token refresh retry", func(t *testing.T) {
@@ -164,9 +163,9 @@ func TestNewActionsServiceRequest(t *testing.T) {
 			errMessage := `{"message":"test"}`
 
 			srv := "http://github.com/my-org"
-			resp := &scaleset.ActionsServiceAdminConnection{
+			resp := &ActionsServiceAdminConnection{
 				AdminToken:        &newToken,
-				ActionsServiceUrl: &srv,
+				ActionsServiceURL: &srv,
 			}
 			failures := 0
 			unauthorizedHandler := func(w http.ResponseWriter, r *http.Request) {
@@ -182,30 +181,30 @@ func TestNewActionsServiceRequest(t *testing.T) {
 				_ = json.NewEncoder(w).Encode(resp)
 			}
 			server := testserver.New(t, nil, testserver.WithActionsToken("random-token"), testserver.WithActionsToken(newToken), testserver.WithActionsRegistrationTokenHandler(unauthorizedHandler))
-			client, err := scaleset.NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
+			client, err := NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
 			require.NoError(t, err)
 			expiringToken := "expiring-token"
 			expiresAt := time.Now().Add(59 * time.Second)
-			client.ActionsServiceAdminToken = expiringToken
+			client.actionsServiceAdminToken = expiringToken
-			client.ActionsServiceAdminTokenExpiresAt = expiresAt
+			client.actionsServiceAdminTokenExpiresAt = expiresAt
 
-			_, err = client.NewActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
+			_, err = client.newActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
 			require.NoError(t, err)
-			assert.Equal(t, client.ActionsServiceAdminToken, newToken)
+			assert.Equal(t, client.actionsServiceAdminToken, newToken)
-			assert.Equal(t, client.ActionsServiceURL, srv)
+			assert.Equal(t, client.actionsServiceURL, srv)
-			assert.NotEqual(t, client.ActionsServiceAdminTokenExpiresAt, expiresAt)
+			assert.NotEqual(t, client.actionsServiceAdminTokenExpiresAt, expiresAt)
 		})
 
 		t.Run("token is currently valid", func(t *testing.T) {
 			tokenThatShouldNotBeFetched := defaultActionsToken(t)
 			server := testserver.New(t, nil, testserver.WithActionsToken(tokenThatShouldNotBeFetched))
 
-			client, err := scaleset.NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
+			client, err := NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
 			require.NoError(t, err)
-			client.ActionsServiceAdminToken = "healthy-token"
+			client.actionsServiceAdminToken = "healthy-token"
-			client.ActionsServiceAdminTokenExpiresAt = time.Now().Add(1 * time.Hour)
+			client.actionsServiceAdminTokenExpiresAt = time.Now().Add(1 * time.Hour)
 
-			req, err := client.NewActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
+			req, err := client.newActionsServiceRequest(ctx, http.MethodGet, "my-path", nil)
 			require.NoError(t, err)
 
 			assert.Equal(t, "Bearer healthy-token", req.Header.Get("Authorization"))
@@ -215,10 +214,10 @@ func TestNewActionsServiceRequest(t *testing.T) {
 	t.Run("builds the right URL including api version", func(t *testing.T) {
 		server := testserver.New(t, nil)
 
-		client, err := scaleset.NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
+		client, err := NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
 		require.NoError(t, err)
 
-		req, err := client.NewActionsServiceRequest(ctx, http.MethodGet, "/my/path?name=banana", nil)
+		req, err := client.newActionsServiceRequest(ctx, http.MethodGet, "/my/path?name=banana", nil)
 		require.NoError(t, err)
 
 		serverURL, err := url.Parse(server.URL)
@@ -234,12 +233,12 @@ func TestNewActionsServiceRequest(t *testing.T) {
 	t.Run("populates header", func(t *testing.T) {
 		server := testserver.New(t, nil)
 
-		client, err := scaleset.NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
+		client, err := NewClient(server.ConfigURLForOrg("my-org"), defaultCreds)
 		require.NoError(t, err)
 
 		client.SetUserAgent(testUserAgent)
 
-		req, err := client.NewActionsServiceRequest(ctx, http.MethodGet, "/my/path", nil)
+		req, err := client.newActionsServiceRequest(ctx, http.MethodGet, "/my/path", nil)
 		require.NoError(t, err)
 
 		assert.Equal(t, testUserAgent.String(), req.Header.Get("User-Agent"))

types.go

@@ -12,9 +12,9 @@ type AcquirableJobList struct {
 }
 
 type AcquirableJob struct {
-	AcquireJobUrl   string   `json:"acquireJobUrl"`
+	AcquireJobURL   string   `json:"acquireJobUrl"`
 	MessageType     string   `json:"messageType"`
-	RunnerRequestId int64    `json:"runnerRequestId"`
+	RunnerRequestID int64    `json:"runnerRequestId"`
 	RepositoryName  string   `json:"repositoryName"`
 	OwnerName       string   `json:"ownerName"`
 	JobWorkflowRef  string   `json:"jobWorkflowRef"`
@@ -28,7 +28,7 @@ type Int64List struct {
 }
 
 type JobAvailable struct {
-	AcquireJobUrl string `json:"acquireJobUrl"`
+	AcquireJobURL string `json:"acquireJobUrl"`
 	JobMessageBase
 }
 
@@ -44,7 +44,7 @@ type JobStarted struct {
 
 type JobCompleted struct {
 	Result     string `json:"result"`
-	RunnerId   int    `json:"runnerId"`
+	RunnerID   int    `json:"runnerId"`
 	RunnerName string `json:"runnerName"`
 	JobMessageBase
 }
@@ -88,14 +88,14 @@ type RunnerGroupList struct {
 }
 
 type RunnerScaleSet struct {
-	Id                 int                      `json:"id,omitempty"`
+	ID                 int                      `json:"id,omitempty"`
 	Name               string                   `json:"name,omitempty"`
-	RunnerGroupId      int                      `json:"runnerGroupId,omitempty"`
+	RunnerGroupID      int                      `json:"runnerGroupId,omitempty"`
 	RunnerGroupName    string                   `json:"runnerGroupName,omitempty"`
 	Labels             []Label                  `json:"labels,omitempty"`
 	RunnerSetting      RunnerSetting            `json:"RunnerSetting,omitempty"`
 	CreatedOn          time.Time                `json:"createdOn,omitempty"`
-	RunnerJitConfigUrl string                   `json:"runnerJitConfigUrl,omitempty"`
+	RunnerJitConfigURL string                   `json:"runnerJitConfigUrl,omitempty"`
 	Statistics         *RunnerScaleSetStatistic `json:"statistics,omitempty"`
 }
 
@@ -105,7 +105,7 @@ type RunnerScaleSetJitRunnerSetting struct {
 }
 
 type RunnerScaleSetMessage struct {
-	MessageId   int64                    `json:"messageId"`
+	MessageID   int64                    `json:"messageId"`
 	MessageType string                   `json:"messageType"`
 	Body        string                   `json:"body"`
 	Statistics  *RunnerScaleSetStatistic `json:"statistics"`
@@ -117,10 +117,10 @@ type runnerScaleSetsResponse struct {
 }
 
 type RunnerScaleSetSession struct {
-	SessionId               *uuid.UUID               `json:"sessionId,omitempty"`
+	SessionID               *uuid.UUID               `json:"sessionId,omitempty"`
 	OwnerName               string                   `json:"ownerName,omitempty"`
 	RunnerScaleSet          *RunnerScaleSet          `json:"runnerScaleSet,omitempty"`
-	MessageQueueUrl         string                   `json:"messageQueueUrl,omitempty"`
+	MessageQueueURL         string                   `json:"messageQueueUrl,omitempty"`
 	MessageQueueAccessToken string                   `json:"messageQueueAccessToken,omitempty"`
 	Statistics              *RunnerScaleSetStatistic `json:"statistics,omitempty"`
 }
@@ -147,9 +147,9 @@ type RunnerReferenceList struct {
 }
 
 type RunnerReference struct {
-	Id               int    `json:"id"`
+	ID               int    `json:"id"`
 	Name             string `json:"name"`
-	RunnerScaleSetId int    `json:"runnerScaleSetId"`
+	RunnerScaleSetID int    `json:"runnerScaleSetId"`
 }
 
 type RunnerScaleSetJitRunnerConfig struct {

user_agent_test.go

@@ -1,14 +1,14 @@
-package scaleset_test
+package scaleset
 
 import (
 	"testing"
 
-	"github.com/actions/scaleset"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestUserAgentInfoString(t *testing.T) {
-	userAgentInfo := scaleset.UserAgentInfo{
+	userAgentInfo := UserAgentInfo{
+		System:     "actions-runner-controller",
 		Version:    "0.1.0",
 		CommitSHA:  "1234567890abcdef",
 		ScaleSetID: 10,