jenkins: add progress bar for running jobs (#781)

Author: brainexe

bot/storage/redis_test.go

@@ -2,6 +2,7 @@ package storage
 
 import (
 	"testing"
+	"time"
 
 	"github.com/alicebob/miniredis/v2"
 	"github.com/redis/go-redis/v9"
@@ -27,7 +28,13 @@ func TestRedisStorage(t *testing.T) {
 
 	t.Run("test error handling", func(t *testing.T) {
 		client := redis.NewClient(&redis.Options{
-			Addr: "invalid.host",
+			Addr:            "invalid.host",
+			MaxRetries:      1,                     // Reduce retries from default 3
+			DialTimeout:     10 * time.Millisecond, // Fast timeout for tests
+			ReadTimeout:     10 * time.Millisecond,
+			WriteTimeout:    10 * time.Millisecond,
+			PoolTimeout:     10 * time.Millisecond,
+			ConnMaxIdleTime: 10 * time.Millisecond,
 		})
 
 		storage := NewRedisStorage(client)

bot/storage/storage_enhanced_test.go

@@ -216,19 +216,19 @@ func TestStorageEnhanced(t *testing.T) {
 	t.Run("test storage performance", func(t *testing.T) {
 		storage := newMemoryStorage()
 
-		// Test writing many keys
+		// Test writing many keys (reduced from 1000 to 100 for faster tests)
 		start := time.Now()
-		for i := range 1000 {
+		for i := range 100 {
 			key := "perf_key_" + string(rune(i))
 			value := "perf_value_" + string(rune(i))
 			err := storage.Write("test_collection", key, value)
 			require.NoError(t, err)
 		}
 		writeDuration := time.Since(start)
 
-		// Test reading many keys
+		// Test reading many keys (reduced from 1000 to 100 for faster tests)
 		start = time.Now()
-		for i := range 1000 {
+		for i := range 100 {
 			key := "perf_key_" + string(rune(i))
 			var value string
 			err := storage.Read("test_collection", key, &value)
@@ -237,8 +237,8 @@ func TestStorageEnhanced(t *testing.T) {
 		}
 		readDuration := time.Since(start)
 
-		// Performance should be reasonable (adjust thresholds as needed)
-		assert.Less(t, writeDuration, time.Second)
-		assert.Less(t, readDuration, time.Second)
+		// Performance should be reasonable (adjusted thresholds for fewer iterations)
+		assert.Less(t, writeDuration, 100*time.Millisecond)
+		assert.Less(t, readDuration, 100*time.Millisecond)
 	})
 }

command/jenkins/client/start_build.go

@@ -18,6 +18,8 @@ import (
 
 var locks = util.NewGroupedLogger()
 
+const progressUpdateInterval = 5 * time.Second
+
 // TriggerJenkinsJob starts a new build with given parameters
 // it will return when the job was started successfully
 // in the background it will watch the current build state and will update the state in the original slack message
@@ -43,8 +45,8 @@ func TriggerJenkinsJob(cfg config.JobConfig, jobName string, jobParams Parameter
 		fmt.Sprintf("inform job %s #%d", jobName, build.GetBuildNumber()),
 	)
 	go func() {
-		// wait until job is not running anymore
-		<-WatchBuild(build)
+		// wait until job is not running anymore and update progress every 30s
+		watchProgress(build, slackClient, message, msgTimestamp)
 		runningCommand.Done()
 
 		// update main message
@@ -227,3 +229,77 @@ func getFinishBuildText(build *gojenkins.Build, user string, jobName string) str
 
 	return text
 }
+
+// watchProgress monitors the build and updates the message with a progress bar every 30 seconds
+func watchProgress(build *gojenkins.Build, slackClient client.SlackClient, ref msg.Ref, msgTimestamp string) {
+	estimatedDuration := time.Duration(build.Raw.EstimatedDuration) * time.Millisecond
+	startTime := time.Now()
+	ticker := time.NewTicker(progressUpdateInterval)
+	defer ticker.Stop()
+
+	buildDone := WatchBuild(build)
+
+	for {
+		select {
+		case <-buildDone:
+			// Build is done, exit the loop
+			return
+		case <-ticker.C:
+			// Update progress
+			elapsed := time.Since(startTime)
+			progress := calculateProgress(elapsed, estimatedDuration)
+			progressBar := renderProgressBar(progress)
+
+			text := fmt.Sprintf(
+				"Job %s running (#%d)\n%s %s / %s",
+				build.Job.GetName(),
+				build.GetBuildNumber(),
+				progressBar,
+				util.FormatDuration(elapsed),
+				util.FormatDuration(estimatedDuration),
+			)
+
+			// update the message in Slack with new progress
+			slackClient.SendMessage(
+				ref,
+				"",
+				slack.MsgOptionUpdate(msgTimestamp),
+				GetAttachment(build, text),
+			)
+		}
+	}
+}
+
+// calculateProgress returns a progress percentage (0.0 to 1.0+)
+func calculateProgress(elapsed, estimated time.Duration) float64 {
+	if estimated <= 0 {
+		return 0
+	}
+	return float64(elapsed) / float64(estimated)
+}
+
+// renderProgressBar creates a visual progress bar using Unicode blocks
+func renderProgressBar(progress float64) string {
+	const barLength = 20
+	filled := int(progress * float64(barLength))
+
+	// Cap filled at barLength for display purposes
+	if filled > barLength {
+		filled = barLength
+	}
+	if filled < 0 {
+		filled = 0
+	}
+
+	bar := ""
+	for i := range barLength {
+		if i < filled {
+			bar += "█"
+		} else {
+			bar += "░"
+		}
+	}
+
+	percentage := int(progress * 100)
+	return fmt.Sprintf("%s %d%%", bar, percentage)
+}

command/jenkins/client/start_build_test.go

@@ -166,6 +166,65 @@ func TestSendBuildStartedMessage(t *testing.T) {
 	assert.Empty(t, msgTimestamp)
 }
 
+func TestCalculateProgress(t *testing.T) {
+	t.Run("Zero estimated duration", func(t *testing.T) {
+		progress := calculateProgress(1*time.Minute, 0)
+		assert.InDelta(t, 0.0, progress, 0.001)
+	})
+
+	t.Run("Half complete", func(t *testing.T) {
+		progress := calculateProgress(30*time.Second, 60*time.Second)
+		assert.InDelta(t, 0.5, progress, 0.001)
+	})
+
+	t.Run("Fully complete", func(t *testing.T) {
+		progress := calculateProgress(60*time.Second, 60*time.Second)
+		assert.InDelta(t, 1.0, progress, 0.001)
+	})
+
+	t.Run("Over estimated time", func(t *testing.T) {
+		progress := calculateProgress(90*time.Second, 60*time.Second)
+		assert.InDelta(t, 1.5, progress, 0.001)
+	})
+}
+
+func TestRenderProgressBar(t *testing.T) {
+	t.Run("Zero progress", func(t *testing.T) {
+		bar := renderProgressBar(0.0)
+		assert.Equal(t, "░░░░░░░░░░░░░░░░░░░░ 0%", bar)
+	})
+
+	t.Run("25% progress", func(t *testing.T) {
+		bar := renderProgressBar(0.25)
+		assert.Equal(t, "█████░░░░░░░░░░░░░░░ 25%", bar)
+	})
+
+	t.Run("50% progress", func(t *testing.T) {
+		bar := renderProgressBar(0.5)
+		assert.Equal(t, "██████████░░░░░░░░░░ 50%", bar)
+	})
+
+	t.Run("75% progress", func(t *testing.T) {
+		bar := renderProgressBar(0.75)
+		assert.Equal(t, "███████████████░░░░░ 75%", bar)
+	})
+
+	t.Run("100% progress", func(t *testing.T) {
+		bar := renderProgressBar(1.0)
+		assert.Equal(t, "████████████████████ 100%", bar)
+	})
+
+	t.Run("Over 100% progress", func(t *testing.T) {
+		bar := renderProgressBar(1.5)
+		assert.Equal(t, "████████████████████ 150%", bar)
+	})
+
+	t.Run("Negative progress", func(t *testing.T) {
+		bar := renderProgressBar(-0.1)
+		assert.Equal(t, "░░░░░░░░░░░░░░░░░░░░ -10%", bar)
+	})
+}
+
 func spawnJenkinsServer() *httptest.Server {
 	mux := http.NewServeMux()
 

command/openai/openai_test.go

@@ -185,7 +185,6 @@ data: [DONE]`,
 				},
 			},
 		)
-		defer ts.Close()
 
 		openaiCfg.InitialSystemMessage = ""
 		cfg := &config.Config{}
@@ -205,6 +204,7 @@ data: [DONE]`,
 
 		actual := commands.Run(message)
 		queue.WaitTillHavingNoQueuedMessage()
+		ts.Close()
 		assert.True(t, actual)
 	})
 
@@ -228,7 +228,6 @@ data: [DONE]`,
 				},
 			},
 		)
-		defer ts.Close()
 
 		openaiCfg.UseAsFallback = true
 		openaiCfg.InitialSystemMessage = ""
@@ -248,6 +247,7 @@ data: [DONE]`,
 
 		actual := commands.Run(message)
 		queue.WaitTillHavingNoQueuedMessage()
+		ts.Close()
 		assert.True(t, actual)
 	})