Implement lb target-pool remove-target command

docs/stackit_load-balancer_target-pool.md

@@ -30,4 +30,5 @@ stackit load-balancer target-pool [flags]
 
 * [stackit load-balancer](./stackit_load-balancer.md)	 - Provides functionality for Load Balancer
 * [stackit load-balancer target-pool add-target](./stackit_load-balancer_target-pool_add-target.md)	 - Adds a target to a target pool
+* [stackit load-balancer target-pool remove-target](./stackit_load-balancer_target-pool_remove-target.md)	 - Removes a target from a target pool
 

docs/stackit_load-balancer_target-pool_add-target.md

@@ -7,23 +7,23 @@ Adds a target to a target pool
 Adds a target to a target pool.
 
 ```
-stackit load-balancer target-pool add-target LOAD_BALANCER_NAME [flags]
+stackit load-balancer target-pool add-target TARGET_POOL_NAME [flags]
 ```
 
 ### Examples
 
 ```
   Add a target to target pool "my-target-pool" of load balancer with name "my-load-balancer"
-  $ stackit load-balancer target-pool add-target my-load-balancer --target-pool-name my-target-pool --target-name my-new-target --ip 1.2.3.4
+  $ stackit load-balancer target-pool add-target my-target-pool --lb-name my-load-balancer --target-name my-new-target --ip 1.2.3.4
 ```
 
 ### Options
 
 ```
-  -h, --help                      Help for "stackit load-balancer target-pool add-target"
-      --ip string                 Target IP. Must by unique within a target pool. Must be a valid IPv4 or IPv6
-      --target-name string        Target name
-      --target-pool-name string   Target pool name
+  -h, --help                 Help for "stackit load-balancer target-pool add-target"
+      --ip string            Target IP. Must by unique within a target pool. Must be a valid IPv4 or IPv6
+      --lb-name string       Load balancer name
+      --target-name string   Target name
 ```
 
 ### Options inherited from parent commands

docs/stackit_load-balancer_target-pool_remove-target.md

@@ -0,0 +1,41 @@
+## stackit load-balancer target-pool remove-target
+
+Removes a target from a target pool
+
+### Synopsis
+
+Removes a target from a target pool.
+
+```
+stackit load-balancer target-pool remove-target TARGET_POOL_NAME [flags]
+```
+
+### Examples
+
+```
+  Remove target with IP 1.2.3.4 from target pool "my-target-pool" of load balancer with name "my-load-balancer"
+  $ stackit load-balancer target-pool remove-target my-target-pool lb-name my-load-balancer --ip 1.2.3.4
+```
+
+### Options
+
+```
+  -h, --help             Help for "stackit load-balancer target-pool remove-target"
+      --ip string        Target IP of the target to remove. Must be a valid IPv4 or IPv6
+      --lb-name string   Load balancer name
+```
+
+### Options inherited from parent commands
+
+```
+  -y, --assume-yes             If set, skips all confirmation prompts
+      --async                  If set, runs the command asynchronously
+  -o, --output-format string   Output format, one of ["json" "pretty" "none"]
+  -p, --project-id string      Project ID
+      --verbosity string       Verbosity of the CLI, one of ["debug" "info" "warning" "error"] (default "info")
+```
+
+### SEE ALSO
+
+* [stackit load-balancer target-pool](./stackit_load-balancer_target-pool.md)	 - Provides functionality for target pools
+

internal/cmd/load-balancer/target-pool/add-target/add_target.go

@@ -18,32 +18,32 @@ import (
 )
 
 const (
-	loadBalancerNameArg = "LOAD_BALANCER_NAME"
+	targetPoolNameArg = "TARGET_POOL_NAME"
 
-	targetPoolNameFlag = "target-pool-name"
-	targetNameFlag     = "target-name"
-	ipFlag             = "ip"
+	lbNameFlag     = "lb-name"
+	targetNameFlag = "target-name"
+	ipFlag         = "ip"
 )
 
 type inputModel struct {
 	*globalflags.GlobalFlagModel
 
-	LoadBalancerName string
-	TargetPoolName   string
-	TargetName       string
-	Ip               string
+	TargetPoolName string
+	LBName         string
+	TargetName     string
+	IP             string
 }
 
 func NewCmd(p *print.Printer) *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   fmt.Sprintf("add-target %s", loadBalancerNameArg),
+		Use:   fmt.Sprintf("add-target %s", targetPoolNameArg),
 		Short: "Adds a target to a target pool",
 		Long:  "Adds a target to a target pool.",
-		Args:  args.SingleArg(loadBalancerNameArg, nil),
+		Args:  args.SingleArg(targetPoolNameArg, nil),
 		Example: examples.Build(
 			examples.NewExample(
 				`Add a target to target pool "my-target-pool" of load balancer with name "my-load-balancer"`,
-				"$ stackit load-balancer target-pool add-target my-load-balancer --target-pool-name my-target-pool --target-name my-new-target --ip 1.2.3.4"),
+				"$ stackit load-balancer target-pool add-target my-target-pool --lb-name my-load-balancer --target-name my-new-target --ip 1.2.3.4"),
 		),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := context.Background()
@@ -59,7 +59,7 @@ func NewCmd(p *print.Printer) *cobra.Command {
 			}
 
 			if !model.AssumeYes {
-				prompt := fmt.Sprintf("Are you sure you want to add a target with IP %q to target pool %q of load balancer %q?", model.Ip, model.TargetPoolName, model.LoadBalancerName)
+				prompt := fmt.Sprintf("Are you sure you want to add a target with IP %q to target pool %q of load balancer %q?", model.IP, model.TargetPoolName, model.LBName)
 				err = p.PromptForConfirmation(prompt)
 				if err != nil {
 					return err
@@ -76,7 +76,7 @@ func NewCmd(p *print.Printer) *cobra.Command {
 				return fmt.Errorf("add target to target pool: %w", err)
 			}
 
-			p.Info("Added target to target pool of load balancer %q\n", model.LoadBalancerName)
+			p.Info("Added target to target pool of load balancer %q\n", model.LBName)
 			return nil
 		},
 	}
@@ -85,28 +85,28 @@ func NewCmd(p *print.Printer) *cobra.Command {
 }
 
 func configureFlags(cmd *cobra.Command) {
-	cmd.Flags().String(targetPoolNameFlag, "", "Target pool name")
+	cmd.Flags().String(lbNameFlag, "", "Load balancer name")
 	cmd.Flags().String(targetNameFlag, "", "Target name")
 	cmd.Flags().String(ipFlag, "", "Target IP. Must by unique within a target pool. Must be a valid IPv4 or IPv6")
 
-	err := flags.MarkFlagsRequired(cmd, targetPoolNameFlag, targetNameFlag, ipFlag)
+	err := flags.MarkFlagsRequired(cmd, lbNameFlag, targetNameFlag, ipFlag)
 	cobra.CheckErr(err)
 }
 
 func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inputModel, error) {
-	lbName := inputArgs[0]
+	targetPoolName := inputArgs[0]
 
 	globalFlags := globalflags.Parse(p, cmd)
 	if globalFlags.ProjectId == "" {
 		return nil, &errors.ProjectIdError{}
 	}
 
 	model := inputModel{
-		GlobalFlagModel:  globalFlags,
-		LoadBalancerName: lbName,
-		TargetPoolName:   cmd.Flag(targetPoolNameFlag).Value.String(),
-		TargetName:       cmd.Flag(targetNameFlag).Value.String(),
-		Ip:               cmd.Flag(ipFlag).Value.String(),
+		GlobalFlagModel: globalFlags,
+		TargetPoolName:  targetPoolName,
+		LBName:          cmd.Flag(lbNameFlag).Value.String(),
+		TargetName:      cmd.Flag(targetNameFlag).Value.String(),
+		IP:              cmd.Flag(ipFlag).Value.String(),
 	}
 
 	if p.IsVerbosityDebug() {
@@ -122,16 +122,16 @@ func parseInput(p *print.Printer, cmd *cobra.Command, inputArgs []string) (*inpu
 }
 
 func buildRequest(ctx context.Context, model *inputModel, apiClient utils.LoadBalancerClient) (loadbalancer.ApiUpdateTargetPoolRequest, error) {
-	req := apiClient.UpdateTargetPool(ctx, model.ProjectId, model.LoadBalancerName, model.TargetPoolName)
+	req := apiClient.UpdateTargetPool(ctx, model.ProjectId, model.LBName, model.TargetPoolName)
 
-	targetPool, err := utils.GetLoadBalancerTargetPool(ctx, apiClient, model.ProjectId, model.LoadBalancerName, model.TargetPoolName)
+	targetPool, err := utils.GetLoadBalancerTargetPool(ctx, apiClient, model.ProjectId, model.LBName, model.TargetPoolName)
 	if err != nil {
 		return req, fmt.Errorf("get load balancer target pool: %w", err)
 	}
 
 	newTarget := &loadbalancer.Target{
 		DisplayName: &model.TargetName,
-		Ip:          &model.Ip,
+		Ip:          &model.IP,
 	}
 	err = utils.AddTargetToTargetPool(targetPool, newTarget)
 	if err != nil {

internal/cmd/load-balancer/target-pool/add-target/add_target_test.go

@@ -26,10 +26,10 @@ var (
 )
 
 const (
-	testLoadBalancerName = "my-load-balancer"
-	testTargetPoolName   = "target-pool-1"
-	testTargetName       = "my-target"
-	testIp               = "1.2.3.4"
+	testLBName         = "my-load-balancer"
+	testTargetPoolName = "target-pool-1"
+	testTargetName     = "my-target"
+	testIP             = "1.2.3.4"
 )
 
 type loadBalancerClientMocked struct {
@@ -59,7 +59,7 @@ func (m *loadBalancerClientMocked) UpdateTargetPool(ctx context.Context, project
 
 func fixtureArgValues(mods ...func(argValues []string)) []string {
 	argValues := []string{
-		testLoadBalancerName,
+		testTargetPoolName,
 	}
 	for _, mod := range mods {
 		mod(argValues)
@@ -69,10 +69,10 @@ func fixtureArgValues(mods ...func(argValues []string)) []string {
 
 func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]string {
 	flagValues := map[string]string{
-		projectIdFlag:      testProjectId,
-		targetPoolNameFlag: testTargetPoolName,
-		targetNameFlag:     testTargetName,
-		ipFlag:             testIp,
+		projectIdFlag:  testProjectId,
+		lbNameFlag:     testLBName,
+		targetNameFlag: testTargetName,
+		ipFlag:         testIP,
 	}
 	for _, mod := range mods {
 		mod(flagValues)
@@ -86,10 +86,10 @@ func fixtureInputModel(mods ...func(model *inputModel)) *inputModel {
 			ProjectId: testProjectId,
 			Verbosity: globalflags.VerbosityDefault,
 		},
-		LoadBalancerName: testLoadBalancerName,
-		TargetPoolName:   testTargetPoolName,
-		TargetName:       testTargetName,
-		Ip:               testIp,
+		TargetPoolName: testTargetPoolName,
+		LBName:         testLBName,
+		TargetName:     testTargetName,
+		IP:             testIP,
 	}
 	for _, mod := range mods {
 		mod(model)
@@ -112,7 +112,7 @@ func fixtureTargets() *[]loadbalancer.Target {
 
 func fixtureLoadBalancer(mods ...func(*loadbalancer.LoadBalancer)) *loadbalancer.LoadBalancer {
 	lb := loadbalancer.LoadBalancer{
-		Name: utils.Ptr(testLoadBalancerName),
+		Name: utils.Ptr(testLBName),
 		TargetPools: &[]loadbalancer.TargetPool{
 			{
 				Name:    utils.Ptr(testTargetPoolName),
@@ -167,7 +167,7 @@ func fixturePayload(mods ...func(payload *loadbalancer.UpdateTargetPoolPayload))
 }
 
 func fixtureRequest(mods ...func(request *loadbalancer.ApiUpdateTargetPoolRequest)) loadbalancer.ApiUpdateTargetPoolRequest {
-	request := testClient.UpdateTargetPool(testCtx, testProjectId, testLoadBalancerName, testTargetPoolName)
+	request := testClient.UpdateTargetPool(testCtx, testProjectId, testLBName, testTargetPoolName)
 	request = request.UpdateTargetPoolPayload(*fixturePayload())
 	for _, mod := range mods {
 		mod(&request)
@@ -221,16 +221,16 @@ func TestParseInput(t *testing.T) {
 			isValid: false,
 		},
 		{
-			description: "load balancer name empty",
+			description: "target pool name missing",
 			argValues:   []string{""},
 			flagValues:  fixtureFlagValues(),
 			isValid:     false,
 		},
 		{
-			description: "target pool name missing",
+			description: "load balancer name missing",
 			argValues:   fixtureArgValues(),
 			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				delete(flagValues, targetPoolNameFlag)
+				delete(flagValues, lbNameFlag)
 			}),
 			isValid: false,
 		},
@@ -328,7 +328,7 @@ func TestBuildRequest(t *testing.T) {
 						(*fixtureTargets())[1],
 						{
 							DisplayName: utils.Ptr(testTargetName),
-							Ip:          utils.Ptr(testIp),
+							Ip:          utils.Ptr(testIP),
 						},
 					}
 				})
@@ -347,7 +347,7 @@ func TestBuildRequest(t *testing.T) {
 					payload.Targets = &[]loadbalancer.Target{
 						{
 							DisplayName: utils.Ptr(testTargetName),
-							Ip:          utils.Ptr(testIp),
+							Ip:          utils.Ptr(testIP),
 						},
 					}
 				})
@@ -366,7 +366,7 @@ func TestBuildRequest(t *testing.T) {
 					payload.Targets = &[]loadbalancer.Target{
 						{
 							DisplayName: utils.Ptr(testTargetName),
-							Ip:          utils.Ptr(testIp),
+							Ip:          utils.Ptr(testIP),
 						},
 					}
 				})