refactor(ngrokapi): Refactor ngrokapi package to better support mocking

internal/controller/ingress/domain_controller.go

@@ -38,9 +38,9 @@ import (
 
 	"github.com/go-logr/logr"
 	"github.com/ngrok/ngrok-api-go/v7"
-	"github.com/ngrok/ngrok-api-go/v7/reserved_domains"
 	ingressv1alpha1 "github.com/ngrok/ngrok-operator/api/ingress/v1alpha1"
 	"github.com/ngrok/ngrok-operator/internal/controller"
+	"github.com/ngrok/ngrok-operator/internal/ngrokapi"
 )
 
 // DomainReconciler reconciles a Domain object
@@ -50,7 +50,7 @@ type DomainReconciler struct {
 	Log           logr.Logger
 	Scheme        *runtime.Scheme
 	Recorder      record.EventRecorder
-	DomainsClient *reserved_domains.Client
+	DomainsClient ngrokapi.DomainClient
 
 	controller *controller.BaseController[*ingressv1alpha1.Domain]
 }

internal/controller/ingress/httpsedge_controller.go

@@ -45,7 +45,6 @@
 
 	"github.com/go-logr/logr"
 	"github.com/ngrok/ngrok-api-go/v7"
-	"github.com/ngrok/ngrok-api-go/v7/backends/tunnel_group"
 	ingressv1alpha1 "github.com/ngrok/ngrok-operator/api/ingress/v1alpha1"
 	"github.com/ngrok/ngrok-operator/internal/controller"
 	ierr "github.com/ngrok/ngrok-operator/internal/errors"
@@ -508,11 +507,11 @@
 
 // Tunnel Group Backend planner
 type tunnelGroupBackendReconciler struct {
-	client   *tunnel_group.Client
+	client   ngrokapi.TunnelGroupBackendsClient
 	backends []*ngrok.TunnelGroupBackend
 }
 
-func newTunnelGroupBackendReconciler(client *tunnel_group.Client) (*tunnelGroupBackendReconciler, error) {
+func newTunnelGroupBackendReconciler(client ngrokapi.TunnelGroupBackendsClient) (*tunnelGroupBackendReconciler, error) {
 	backends := make([]*ngrok.TunnelGroupBackend, 0)
 	iter := client.List(&ngrok.Paging{})
 	for iter.Next(context.Background()) {

internal/controller/ingress/ippolicy_controller.go

@@ -37,10 +37,9 @@ import (
 
 	"github.com/go-logr/logr"
 	"github.com/ngrok/ngrok-api-go/v7"
-	"github.com/ngrok/ngrok-api-go/v7/ip_policies"
-	"github.com/ngrok/ngrok-api-go/v7/ip_policy_rules"
 	ingressv1alpha1 "github.com/ngrok/ngrok-operator/api/ingress/v1alpha1"
 	"github.com/ngrok/ngrok-operator/internal/controller"
+	"github.com/ngrok/ngrok-operator/internal/ngrokapi"
 )
 
 const (
@@ -56,8 +55,8 @@ type IPPolicyReconciler struct {
 	Scheme   *runtime.Scheme
 	Recorder record.EventRecorder
 
-	IPPoliciesClient    *ip_policies.Client
-	IPPolicyRulesClient *ip_policy_rules.Client
+	IPPoliciesClient    ngrokapi.IPPoliciesClient
+	IPPolicyRulesClient ngrokapi.IPPolicyRulesClient
 
 	controller *controller.BaseController[*ingressv1alpha1.IPPolicy]
 }

internal/ngrokapi/bindingendpoint_aggregator_test.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	v6 "github.com/ngrok/ngrok-api-go/v7"
+	"github.com/ngrok/ngrok-api-go/v7"
 	bindingsv1alpha1 "github.com/ngrok/ngrok-operator/api/bindings/v1alpha1"
 )
 
@@ -52,14 +52,14 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 
 	tests := []struct {
 		name      string
-		endpoints []v6.Endpoint
+		endpoints []ngrok.Endpoint
 		want      AggregatedEndpoints
 		wantErr   bool
 	}{
-		{"empty", []v6.Endpoint{}, AggregatedEndpoints{}, false},
+		{"empty", []ngrok.Endpoint{}, AggregatedEndpoints{}, false},
 		{
 			name: "single",
-			endpoints: []v6.Endpoint{
+			endpoints: []ngrok.Endpoint{
 				{ID: "ep_123", PublicURL: "https://service1.namespace1"},
 			},
 			want: AggregatedEndpoints{
@@ -76,7 +76,7 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_123"}},
+							{Ref: ngrok.Ref{ID: "ep_123"}},
 						},
 					},
 				},
@@ -85,7 +85,7 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 		},
 		{
 			name: "full",
-			endpoints: []v6.Endpoint{
+			endpoints: []ngrok.Endpoint{
 				{ID: "ep_100", PublicURL: "https://service1.namespace1"},
 				{ID: "ep_101", PublicURL: "https://service1.namespace1"},
 				{ID: "ep_102", PublicURL: "https://service1.namespace1"},
@@ -108,9 +108,9 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_100"}},
-							{Ref: v6.Ref{ID: "ep_101"}},
-							{Ref: v6.Ref{ID: "ep_102"}},
+							{Ref: ngrok.Ref{ID: "ep_100"}},
+							{Ref: ngrok.Ref{ID: "ep_101"}},
+							{Ref: ngrok.Ref{ID: "ep_102"}},
 						},
 					},
 				},
@@ -127,8 +127,8 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_200"}},
-							{Ref: v6.Ref{ID: "ep_201"}},
+							{Ref: ngrok.Ref{ID: "ep_200"}},
+							{Ref: ngrok.Ref{ID: "ep_201"}},
 						},
 					},
 				},
@@ -145,7 +145,7 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_300"}},
+							{Ref: ngrok.Ref{ID: "ep_300"}},
 						},
 					},
 				},
@@ -162,7 +162,7 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_400"}},
+							{Ref: ngrok.Ref{ID: "ep_400"}},
 						},
 					},
 				},

internal/ngrokapi/clientset.go

@@ -1,6 +1,8 @@
 package ngrokapi
 
 import (
+	"context"
+
 	"github.com/ngrok/ngrok-api-go/v7"
 	tunnel_group_backends "github.com/ngrok/ngrok-api-go/v7/backends/tunnel_group"
 	https_edges "github.com/ngrok/ngrok-api-go/v7/edges/https"
@@ -16,18 +18,18 @@
 )
 
 type Clientset interface {
-	Domains() *reserved_domains.Client
+	Domains() DomainClient
 	EdgeModules() EdgeModulesClientset
-	Endpoints() *endpoints.Client
-	HTTPSEdges() *https_edges.Client
-	HTTPSEdgeRoutes() *https_edge_routes.Client
-	IPPolicies() *ip_policies.Client
-	IPPolicyRules() *ip_policy_rules.Client
-	KubernetesOperators() *kubernetes_operators.Client
-	TCPAddresses() *reserved_addrs.Client
-	TCPEdges() *tcp_edges.Client
-	TLSEdges() *tls_edges.Client
-	TunnelGroupBackends() *tunnel_group_backends.Client
+	Endpoints() EndpointsClient
+	HTTPSEdges() HTTPSEdgeClient
+	HTTPSEdgeRoutes() HTTPSEdgeRoutesClient
+	IPPolicies() IPPoliciesClient
+	IPPolicyRules() IPPolicyRulesClient
+	KubernetesOperators() KubernetesOperatorsClient
+	TCPAddresses() TCPAddressesClient
+	TCPEdges() TCPEdgesClient
+	TLSEdges() TLSEdgesClient
+	TunnelGroupBackends() TunnelGroupBackendsClient
 }
 
 type DefaultClientset struct {
@@ -63,50 +65,153 @@
 	}
 }
 
-func (c *DefaultClientset) Domains() *reserved_domains.Client {
+type Creator[R, T any] interface {
+	Create(context.Context, R) (T, error)
+}
+
+type Reader[T any] interface {
+	Get(context.Context, string) (T, error)
+}
+
+type Updater[R, T any] interface {
+	Update(context.Context, R) (T, error)
+}
+
+type Deletor interface {
+	Delete(context.Context, string) error
+}
+
+type Lister[T any] interface {
+	List(*ngrok.Paging) ngrok.Iter[T]
+}
+
+type DomainClient interface {
+	Creator[*ngrok.ReservedDomainCreate, *ngrok.ReservedDomain]
+	Reader[*ngrok.ReservedDomain]
+	Updater[*ngrok.ReservedDomainUpdate, *ngrok.ReservedDomain]
+	Deletor
+	Lister[*ngrok.ReservedDomain]
+}
+
+func (c *DefaultClientset) Domains() DomainClient {
 	return c.domainsClient
 }
 
 func (c *DefaultClientset) EdgeModules() EdgeModulesClientset {
 	return c.edgeModulesClientset
 }
 
-func (c *DefaultClientset) Endpoints() *endpoints.Client {
+type EndpointsClient interface {
+	Creator[*ngrok.EndpointCreate, *ngrok.Endpoint]
+	Reader[*ngrok.Endpoint]
+	Updater[*ngrok.EndpointUpdate, *ngrok.Endpoint]
+	Deletor
+	Lister[*ngrok.Endpoint]
+}
+
+func (c *DefaultClientset) Endpoints() EndpointsClient {
 	return c.endpointsClient
 }
 
-func (c *DefaultClientset) HTTPSEdges() *https_edges.Client {
+type HTTPSEdgeClient interface {
+	Creator[*ngrok.HTTPSEdgeCreate, *ngrok.HTTPSEdge]
+	Reader[*ngrok.HTTPSEdge]
+	Updater[*ngrok.HTTPSEdgeUpdate, *ngrok.HTTPSEdge]
+	Deletor
+	Lister[*ngrok.HTTPSEdge]
+}
+
+func (c *DefaultClientset) HTTPSEdges() HTTPSEdgeClient {
 	return c.httpsEdgesClient
 }
 
-func (c *DefaultClientset) HTTPSEdgeRoutes() *https_edge_routes.Client {
+type HTTPSEdgeRoutesClient interface {
+	Creator[*ngrok.HTTPSEdgeRouteCreate, *ngrok.HTTPSEdgeRoute]
+	Get(context.Context, *ngrok.EdgeRouteItem) (*ngrok.HTTPSEdgeRoute, error)
+	Updater[*ngrok.HTTPSEdgeRouteUpdate, *ngrok.HTTPSEdgeRoute]
+	Delete(context.Context, *ngrok.EdgeRouteItem) error
+}
+
+func (c *DefaultClientset) HTTPSEdgeRoutes() HTTPSEdgeRoutesClient {
 	return c.httpsEdgeRoutesClient
 }
 
-func (c *DefaultClientset) IPPolicies() *ip_policies.Client {
+type IPPoliciesClient interface {
+	Creator[*ngrok.IPPolicyCreate, *ngrok.IPPolicy]
+	Reader[*ngrok.IPPolicy]
+	Updater[*ngrok.IPPolicyUpdate, *ngrok.IPPolicy]
+	Deletor
+}
+
+func (c *DefaultClientset) IPPolicies() IPPoliciesClient {
 	return c.ipPoliciesClient
 }
 
-func (c *DefaultClientset) IPPolicyRules() *ip_policy_rules.Client {
+type IPPolicyRulesClient interface {
+	Creator[*ngrok.IPPolicyRuleCreate, *ngrok.IPPolicyRule]
+	Deletor
+	Updater[*ngrok.IPPolicyRuleUpdate, *ngrok.IPPolicyRule]
+	Lister[*ngrok.IPPolicyRule]
+}
+
+func (c *DefaultClientset) IPPolicyRules() IPPolicyRulesClient {
 	return c.ipPolicyRulesClient
 }
 
-func (c *DefaultClientset) KubernetesOperators() *kubernetes_operators.Client {
+type KubernetesOperatorsClient interface {
+	Creator[*ngrok.KubernetesOperatorCreate, *ngrok.KubernetesOperator]
+	Reader[*ngrok.KubernetesOperator]
+	Updater[*ngrok.KubernetesOperatorUpdate, *ngrok.KubernetesOperator]
+	Deletor
+	Lister[*ngrok.KubernetesOperator]
+	GetBoundEndpoints(string, *ngrok.Paging) ngrok.Iter[*ngrok.Endpoint]
+}
+
+func (c *DefaultClientset) KubernetesOperators() KubernetesOperatorsClient {
 	return c.kubernetesOperatorsClient
 }
 
-func (c *DefaultClientset) TCPAddresses() *reserved_addrs.Client {
+type TCPAddressesClient interface {
+	Creator[*ngrok.ReservedAddrCreate, *ngrok.ReservedAddr]
+	Updater[*ngrok.ReservedAddrUpdate, *ngrok.ReservedAddr]
+	Lister[*ngrok.ReservedAddr]
+}
+
+func (c *DefaultClientset) TCPAddresses() TCPAddressesClient {
 	return c.tcpAddrsClient
 }
 
-func (c *DefaultClientset) TLSEdges() *tls_edges.Client {
+type TLSEdgesClient interface {
+	Creator[*ngrok.TLSEdgeCreate, *ngrok.TLSEdge]
+	Reader[*ngrok.TLSEdge]
+	Updater[*ngrok.TLSEdgeUpdate, *ngrok.TLSEdge]
+	Deletor
+	Lister[*ngrok.TLSEdge]
+}
+
+func (c *DefaultClientset) TLSEdges() TLSEdgesClient {
 	return c.tlsEdgesClient
 }
 
-func (c *DefaultClientset) TCPEdges() *tcp_edges.Client {
+type TCPEdgesClient interface {
+	Creator[*ngrok.TCPEdgeCreate, *ngrok.TCPEdge]
+	Reader[*ngrok.TCPEdge]
+	Updater[*ngrok.TCPEdgeUpdate, *ngrok.TCPEdge]
+	Deletor
+	Lister[*ngrok.TCPEdge]
+}
+
+func (c *DefaultClientset) TCPEdges() TCPEdgesClient {
 	return c.tcpEdgesClient
 }
 
-func (c *DefaultClientset) TunnelGroupBackends() *tunnel_group_backends.Client {
+type TunnelGroupBackendsClient interface {
+	Creator[*ngrok.TunnelGroupBackendCreate, *ngrok.TunnelGroupBackend]
+	Reader[*ngrok.TunnelGroupBackend]
+	Updater[*ngrok.TunnelGroupBackendUpdate, *ngrok.TunnelGroupBackend]
+	Lister[*ngrok.TunnelGroupBackend]
+}
+
+func (c *DefaultClientset) TunnelGroupBackends() TunnelGroupBackendsClient {
 	return c.tunnelGroupBackendsClient
 }

internal/ngrokapi/edge_modules_clientset.go

@@ -1,13 +1,30 @@
 package ngrokapi
 
-import "github.com/ngrok/ngrok-api-go/v7"
+import (
+	"context"
+
+	"github.com/ngrok/ngrok-api-go/v7"
+)
 
 type EdgeModulesClientset interface {
 	TCP() TCPEdgeModulesClientset
 	HTTPS() HTTPSEdgeModulesClientset
 	TLS() TLSEdgeModulesClientset
 }
 
+type edgeModulesClient[R, T any] interface {
+	Deletor
+	Replace(context.Context, R) (T, error)
+}
+
+type EdgeRouteModulesDeletor interface {
+	Delete(context.Context, *ngrok.EdgeRouteItem) error
+}
+
+type EdgeRouteModulesReplacer[R, T any] interface {
+	Replace(context.Context, R) (T, error)
+}
+
 type defaultEdgeModulesClientset struct {
 	tcp   *defaultTCPEdgeModulesClientset
 	https *defaultHTTPSEdgeModulesClientset