Fix work pool naming inconsistency that prevented worker connections (#207)

## Summary

Fixes a naming inconsistency between what the controller creates in the
Prefect API and what workers try to connect to for work pools starting
with "prefect".

Previously, the `EntrypointArguments()` method would prepend "pool-" to
work pool names starting with "prefect", causing workers to attempt
connections to work pools that didn't exist in the API.

For example:
- Controller would create work pool: `prefect-work-pool`
- Worker would try to connect to: `pool-prefect-work-pool`
- Result: Worker connection failures

Now both use the exact work pool name from the Kubernetes resource,
ensuring proper connectivity.

## Breaking Change

This is a breaking change for users with work pools starting with
"prefect". They'll need to:
1. Delete existing PrefectWorkPool resources  
2. Recreate them with the same names
3. Update any PrefectDeployment references

However, the previous behavior was fundamentally broken anyway, so this
fixes existing deployments rather than introducing new issues.

## Testing

- All existing unit and controller tests pass
- Added comprehensive tests for naming consistency
- Verified fix with end-to-end testing of various naming patterns

Closes #206

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-authored-by: Claude <noreply@anthropic.com>

Author: chrisguidry

api/v1/prefectworkpool_types.go

@@ -17,8 +17,6 @@ limitations under the License.
 package v1
 
 import (
-	"strings"
-
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
@@ -136,13 +134,9 @@ func (s *PrefectWorkPool) Image() string {
 }
 
 func (s *PrefectWorkPool) EntrypointArguments() []string {
-	workPoolName := s.Name
-	if strings.HasPrefix(workPoolName, "prefect") {
-		workPoolName = "pool-" + workPoolName
-	}
 	return []string{
 		"prefect", "worker", "start",
-		"--pool", workPoolName, "--type", s.Spec.Type,
+		"--pool", s.Name, "--type", s.Spec.Type,
 		"--with-healthcheck",
 	}
 }

api/v1/prefectworkpool_types_test.go

@@ -46,4 +46,101 @@ var _ = Describe("PrefectWorkPool type", func() {
 		Expect(copied).To(Equal(original))
 		Expect(copied).NotTo(BeIdenticalTo(original))
 	})
+
+	Describe("EntrypointArguments", func() {
+		It("should use exact work pool name for names starting with 'prefect'", func() {
+			workPool := &PrefectWorkPool{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "prefect-work-pool",
+				},
+				Spec: PrefectWorkPoolSpec{
+					Type: "kubernetes",
+				},
+			}
+
+			args := workPool.EntrypointArguments()
+			Expect(args).To(ContainElement("prefect-work-pool"))
+			Expect(args).To(Equal([]string{
+				"prefect", "worker", "start",
+				"--pool", "prefect-work-pool", "--type", "kubernetes",
+				"--with-healthcheck",
+			}))
+		})
+
+		It("should use exact work pool name for names not starting with 'prefect'", func() {
+			workPool := &PrefectWorkPool{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "my-work-pool",
+				},
+				Spec: PrefectWorkPoolSpec{
+					Type: "process",
+				},
+			}
+
+			args := workPool.EntrypointArguments()
+			Expect(args).To(ContainElement("my-work-pool"))
+			Expect(args).To(Equal([]string{
+				"prefect", "worker", "start",
+				"--pool", "my-work-pool", "--type", "process",
+				"--with-healthcheck",
+			}))
+		})
+
+		It("ensures naming consistency between controller and worker", func() {
+			workPool := &PrefectWorkPool{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "prefect-production",
+				},
+				Spec: PrefectWorkPoolSpec{
+					Type: "kubernetes",
+				},
+			}
+
+			controllerName := workPool.Name
+
+			workerArgs := workPool.EntrypointArguments()
+			var workerPoolName string
+			for i, arg := range workerArgs {
+				if arg == "--pool" && i+1 < len(workerArgs) {
+					workerPoolName = workerArgs[i+1]
+					break
+				}
+			}
+
+			Expect(controllerName).To(Equal("prefect-production"))
+			Expect(workerPoolName).To(Equal("prefect-production"))
+			Expect(controllerName).To(Equal(workerPoolName))
+		})
+
+		It("should work consistently for all naming patterns", func() {
+			testCases := []struct {
+				name         string
+				expectedPool string
+			}{
+				{"prefect", "prefect"},
+				{"prefect-k8s", "prefect-k8s"},
+				{"prefect123", "prefect123"},
+				{"k8s-pool", "k8s-pool"},
+				{"my-prefect-pool", "my-prefect-pool"},
+				{"PREFECT-POOL", "PREFECT-POOL"},
+				{"production-pool", "production-pool"},
+				{"dev", "dev"},
+			}
+
+			for _, tc := range testCases {
+				workPool := &PrefectWorkPool{
+					ObjectMeta: metav1.ObjectMeta{
+						Name: tc.name,
+					},
+					Spec: PrefectWorkPoolSpec{
+						Type: "process",
+					},
+				}
+
+				args := workPool.EntrypointArguments()
+				Expect(args).To(ContainElement(tc.expectedPool),
+					"Work pool %s should use pool name %s", tc.name, tc.expectedPool)
+			}
+		})
+	})
 })