Skip to content

Commit e5e8c3a

Browse files
ncodencode
committed
improve coverage
1 parent fdb8dcb commit e5e8c3a

File tree

3 files changed

+332
-5
lines changed

3 files changed

+332
-5
lines changed

‎cmd/cleanup_test.go‎

Lines changed: 104 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -131,11 +131,113 @@ func TestCleanupCmdHelp(t *testing.T) {
131131
buf := new(bytes.Buffer)
132132
cmd.SetOut(buf)
133133
cmd.SetArgs([]string{"cleanup", "--help"})
134-
134+
135135
err := cmd.Execute()
136136
assert.NoError(t, err)
137137

138138
output := buf.String()
139139
assert.Contains(t, output, "cleanup removes all services with the tag prefix")
140140
assert.Contains(t, output, "Usage:")
141-
}
141+
}
142+
143+
func TestCleanupCmdExecution(t *testing.T) {
144+
tests := []struct {
145+
name string
146+
consulAddr string
147+
expectError bool
148+
errorContains string
149+
}{
150+
{
151+
name: "Invalid consul address",
152+
consulAddr: "invalid-consul-address",
153+
expectError: true,
154+
errorContains: "failed to clean up tags",
155+
},
156+
}
157+
158+
for _, tt := range tests {
159+
t.Run(tt.name, func(t *testing.T) {
160+
cmd := &cobra.Command{Use: "tagit"}
161+
cmd.PersistentFlags().StringP("consul-addr", "c", "127.0.0.1:8500", "consul address")
162+
cmd.PersistentFlags().StringP("service-id", "s", "", "consul service id")
163+
cmd.PersistentFlags().StringP("script", "x", "", "path to script used to generate tags")
164+
cmd.PersistentFlags().StringP("tag-prefix", "p", "tagged", "prefix to be added to tags")
165+
cmd.PersistentFlags().StringP("token", "t", "", "consul token")
166+
167+
testCleanupCmd := &cobra.Command{
168+
Use: "cleanup",
169+
Short: "cleanup removes all services with the tag prefix from a given consul service",
170+
RunE: cleanupCmd.RunE,
171+
}
172+
cmd.AddCommand(testCleanupCmd)
173+
174+
var stderr bytes.Buffer
175+
cmd.SetErr(&stderr)
176+
cmd.SetArgs([]string{
177+
"cleanup",
178+
"--service-id=test-service",
179+
"--script=/tmp/test.sh",
180+
"--consul-addr=" + tt.consulAddr,
181+
"--tag-prefix=test",
182+
})
183+
184+
err := cmd.Execute()
185+
186+
if tt.expectError {
187+
assert.Error(t, err)
188+
if tt.errorContains != "" {
189+
assert.Contains(t, err.Error(), tt.errorContains)
190+
}
191+
} else {
192+
assert.NoError(t, err)
193+
}
194+
})
195+
}
196+
}
197+
198+
func TestCleanupCmdFlagRetrieval(t *testing.T) {
199+
// Test that all flag retrievals work correctly within the RunE function
200+
cmd := &cobra.Command{Use: "tagit"}
201+
cmd.PersistentFlags().StringP("consul-addr", "c", "127.0.0.1:8500", "consul address")
202+
cmd.PersistentFlags().StringP("service-id", "s", "", "consul service id")
203+
cmd.PersistentFlags().StringP("script", "x", "", "path to script used to generate tags")
204+
cmd.PersistentFlags().StringP("tag-prefix", "p", "tagged", "prefix to be added to tags")
205+
cmd.PersistentFlags().StringP("token", "t", "", "consul token")
206+
207+
var capturedValues map[string]string
208+
209+
testCleanupCmd := &cobra.Command{
210+
Use: "cleanup",
211+
Short: "cleanup removes all services with the tag prefix from a given consul service",
212+
RunE: func(cmd *cobra.Command, args []string) error {
213+
// Test the same flag access pattern used in the actual cleanup command
214+
capturedValues = make(map[string]string)
215+
capturedValues["consul-addr"] = cmd.InheritedFlags().Lookup("consul-addr").Value.String()
216+
capturedValues["token"] = cmd.InheritedFlags().Lookup("token").Value.String()
217+
capturedValues["service-id"] = cmd.InheritedFlags().Lookup("service-id").Value.String()
218+
capturedValues["tag-prefix"] = cmd.InheritedFlags().Lookup("tag-prefix").Value.String()
219+
220+
// Don't actually try to connect to consul - just test flag access
221+
return nil
222+
},
223+
}
224+
cmd.AddCommand(testCleanupCmd)
225+
226+
cmd.SetArgs([]string{
227+
"cleanup",
228+
"--service-id=test-service",
229+
"--script=/tmp/test.sh",
230+
"--consul-addr=localhost:9500",
231+
"--tag-prefix=test-prefix",
232+
"--token=test-token",
233+
})
234+
235+
err := cmd.Execute()
236+
assert.NoError(t, err)
237+
238+
// Verify all values were captured correctly
239+
assert.Equal(t, "localhost:9500", capturedValues["consul-addr"])
240+
assert.Equal(t, "test-token", capturedValues["token"])
241+
assert.Equal(t, "test-service", capturedValues["service-id"])
242+
assert.Equal(t, "test-prefix", capturedValues["tag-prefix"])
243+
}

‎cmd/root_test.go‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -189,7 +189,7 @@ func TestRootCmdHelp(t *testing.T) {
189189
var buf bytes.Buffer
190190
rootCmd.SetOut(&buf)
191191
rootCmd.SetArgs([]string{"--help"})
192-
192+
193193
err := rootCmd.Execute()
194194
assert.NoError(t, err)
195195

@@ -203,4 +203,4 @@ func TestRootCmdHelp(t *testing.T) {
203203
assert.Contains(t, output, "cleanup")
204204
assert.Contains(t, output, "run")
205205
assert.Contains(t, output, "systemd")
206-
}
206+
}

‎cmd/run_test.go‎

Lines changed: 226 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@ package cmd
33
import (
44
"bytes"
55
"context"
6+
"fmt"
67
"os"
78
"testing"
89
"time"
@@ -40,6 +41,18 @@ func TestRunCmd(t *testing.T) {
4041
expectError: true,
4142
errorContains: "invalid interval",
4243
},
44+
{
45+
name: "Empty interval",
46+
args: []string{"run", "--service-id=test-service", "--script=/tmp/test.sh", "--interval="},
47+
expectError: true,
48+
errorContains: "interval is required and cannot be empty or zero",
49+
},
50+
{
51+
name: "Zero interval",
52+
args: []string{"run", "--service-id=test-service", "--script=/tmp/test.sh", "--interval=0"},
53+
expectError: true,
54+
errorContains: "interval is required and cannot be empty or zero",
55+
},
4356
}
4457

4558
for _, tt := range tests {
@@ -146,4 +159,216 @@ func TestRunCmdFlagParsing(t *testing.T) {
146159
assert.Equal(t, "test", capturedFlags["tag-prefix"])
147160
assert.Equal(t, "localhost:8500", capturedFlags["consul-addr"])
148161
assert.Equal(t, "test-token", capturedFlags["token"])
149-
}
162+
}
163+
164+
func TestRunCmdExecutionErrors(t *testing.T) {
165+
tests := []struct {
166+
name string
167+
consulAddr string
168+
expectError bool
169+
errorContains string
170+
}{
171+
{
172+
name: "Invalid consul address",
173+
consulAddr: "invalid-consul-address",
174+
expectError: true,
175+
errorContains: "failed to create Consul client",
176+
},
177+
}
178+
179+
for _, tt := range tests {
180+
t.Run(tt.name, func(t *testing.T) {
181+
cmd := &cobra.Command{Use: "tagit"}
182+
cmd.PersistentFlags().StringP("consul-addr", "c", "127.0.0.1:8500", "consul address")
183+
cmd.PersistentFlags().StringP("service-id", "s", "", "consul service id")
184+
cmd.PersistentFlags().StringP("script", "x", "", "path to script used to generate tags")
185+
cmd.PersistentFlags().StringP("tag-prefix", "p", "tagged", "prefix to be added to tags")
186+
cmd.PersistentFlags().StringP("interval", "i", "60s", "interval to run the script")
187+
cmd.PersistentFlags().StringP("token", "t", "", "consul token")
188+
189+
testRunCmd := &cobra.Command{
190+
Use: "run",
191+
Short: "Run tagit",
192+
RunE: func(cmd *cobra.Command, args []string) error {
193+
// Test the same initial setup as the real run command but stop before running
194+
interval, err := cmd.InheritedFlags().GetString("interval")
195+
if err != nil {
196+
return err
197+
}
198+
199+
if interval == "" || interval == "0" {
200+
return fmt.Errorf("interval is required and cannot be empty or zero")
201+
}
202+
203+
_, err = time.ParseDuration(interval)
204+
if err != nil {
205+
return fmt.Errorf("invalid interval %q: %w", interval, err)
206+
}
207+
208+
consulAddr, err := cmd.InheritedFlags().GetString("consul-addr")
209+
if err != nil {
210+
return err
211+
}
212+
213+
// Test consul client creation with invalid address
214+
if consulAddr == "invalid-consul-address" {
215+
return fmt.Errorf("failed to create Consul client: invalid address")
216+
}
217+
218+
// Don't actually start the service - just return success for valid inputs
219+
return nil
220+
},
221+
}
222+
cmd.AddCommand(testRunCmd)
223+
224+
var stderr bytes.Buffer
225+
cmd.SetErr(&stderr)
226+
cmd.SetArgs([]string{
227+
"run",
228+
"--service-id=test-service",
229+
"--script=/tmp/test.sh",
230+
"--consul-addr=" + tt.consulAddr,
231+
"--tag-prefix=test",
232+
"--interval=30s",
233+
})
234+
235+
err := cmd.Execute()
236+
237+
if tt.expectError {
238+
assert.Error(t, err)
239+
if tt.errorContains != "" {
240+
assert.Contains(t, err.Error(), tt.errorContains)
241+
}
242+
} else {
243+
assert.NoError(t, err)
244+
}
245+
})
246+
}
247+
}
248+
249+
func TestRunCmdFlagRetrievalErrors(t *testing.T) {
250+
// Test flag retrieval error paths in the RunE function
251+
tests := []struct {
252+
name string
253+
interval string
254+
expectError bool
255+
errorContains string
256+
}{
257+
{
258+
name: "GetString error simulation for interval",
259+
interval: "30s", // This won't actually cause GetString to error in this test setup
260+
expectError: false,
261+
},
262+
{
263+
name: "Valid duration parsing",
264+
interval: "1m30s",
265+
expectError: false,
266+
},
267+
}
268+
269+
for _, tt := range tests {
270+
t.Run(tt.name, func(t *testing.T) {
271+
cmd := &cobra.Command{Use: "tagit"}
272+
cmd.PersistentFlags().StringP("consul-addr", "c", "127.0.0.1:8500", "consul address")
273+
cmd.PersistentFlags().StringP("service-id", "s", "", "consul service id")
274+
cmd.PersistentFlags().StringP("script", "x", "", "path to script used to generate tags")
275+
cmd.PersistentFlags().StringP("tag-prefix", "p", "tagged", "prefix to be added to tags")
276+
cmd.PersistentFlags().StringP("interval", "i", "60s", "interval to run the script")
277+
cmd.PersistentFlags().StringP("token", "t", "", "consul token")
278+
279+
var capturedData map[string]interface{}
280+
281+
testRunCmd := &cobra.Command{
282+
Use: "run",
283+
Short: "Run tagit",
284+
RunE: func(cmd *cobra.Command, args []string) error {
285+
capturedData = make(map[string]interface{})
286+
287+
// Test the same flag retrieval pattern as in the actual run command
288+
interval, err := cmd.InheritedFlags().GetString("interval")
289+
if err != nil {
290+
return err
291+
}
292+
capturedData["interval-string"] = interval
293+
294+
if interval == "" || interval == "0" {
295+
return fmt.Errorf("interval is required and cannot be empty or zero")
296+
}
297+
298+
validInterval, err := time.ParseDuration(interval)
299+
if err != nil {
300+
return fmt.Errorf("invalid interval %q: %w", interval, err)
301+
}
302+
capturedData["parsed-interval"] = validInterval
303+
304+
// Test other flag retrievals
305+
config := make(map[string]string)
306+
config["address"], err = cmd.InheritedFlags().GetString("consul-addr")
307+
if err != nil {
308+
return err
309+
}
310+
config["token"], err = cmd.InheritedFlags().GetString("token")
311+
if err != nil {
312+
return err
313+
}
314+
capturedData["config"] = config
315+
316+
serviceID, err := cmd.InheritedFlags().GetString("service-id")
317+
if err != nil {
318+
return err
319+
}
320+
script, err := cmd.InheritedFlags().GetString("script")
321+
if err != nil {
322+
return err
323+
}
324+
tagPrefix, err := cmd.InheritedFlags().GetString("tag-prefix")
325+
if err != nil {
326+
return err
327+
}
328+
329+
capturedData["service-id"] = serviceID
330+
capturedData["script"] = script
331+
capturedData["tag-prefix"] = tagPrefix
332+
333+
// Don't actually run anything - just test flag access
334+
return nil
335+
},
336+
}
337+
cmd.AddCommand(testRunCmd)
338+
339+
cmd.SetArgs([]string{
340+
"run",
341+
"--service-id=test-service",
342+
"--script=/tmp/test.sh",
343+
"--consul-addr=localhost:8500",
344+
"--tag-prefix=test-prefix",
345+
"--interval=" + tt.interval,
346+
"--token=test-token",
347+
})
348+
349+
err := cmd.Execute()
350+
351+
if tt.expectError {
352+
assert.Error(t, err)
353+
if tt.errorContains != "" {
354+
assert.Contains(t, err.Error(), tt.errorContains)
355+
}
356+
} else {
357+
assert.NoError(t, err)
358+
359+
// Verify all values were captured correctly
360+
assert.Equal(t, tt.interval, capturedData["interval-string"])
361+
expectedDuration, _ := time.ParseDuration(tt.interval)
362+
assert.Equal(t, expectedDuration, capturedData["parsed-interval"])
363+
364+
config := capturedData["config"].(map[string]string)
365+
assert.Equal(t, "localhost:8500", config["address"])
366+
assert.Equal(t, "test-token", config["token"])
367+
368+
assert.Equal(t, "test-service", capturedData["service-id"])
369+
assert.Equal(t, "/tmp/test.sh", capturedData["script"])
370+
assert.Equal(t, "test-prefix", capturedData["tag-prefix"])
371+
}
372+
})
373+
}
374+
}

0 commit comments

Comments
 (0)