feat: human friendly duration formatting (#59)

* feat: updates to fix time

* feat: updates to fix time for all the tests

* feat: add duration util file

* feat: cleanup html files

* feat: revert the deployment image

* feat: removal of md file

* feat: fixing test case coverages

* feat: fixing compiling issues

* fix: fixing route register issue

* fix: fixing the test execution issue

* fix: application startup issue fix

* feat: updated to use the ginko framework and removed commented codes: issue-37

* feat: test execution duplicates resolved: issue-37

* Remove legacy handler test file

* Apply automated lint fixes

* updating the correct values in deployment file

* removal of legacy code

* removal of test files

* feature: removing files with only space changes: #37

* fix: fix for the test run: #37

---------

Co-authored-by: Sundar OK <[email protected]>

Author: mailprak

deployments/fern-platform-kubevela.yaml

@@ -604,6 +604,8 @@ spec:
         env:
           - name: LOG_LEVEL
             value: debug
+          - name: FERN_USE_SPLIT_HANDLERS
+            value: "true"
           - name: REDIS_HOST
             value: redis
           - name: REDIS_PORT

internal/api/domain_handler.go

@@ -134,9 +134,6 @@ func (h *DomainHandler) RegisterRoutes(router *gin.Engine) {
 
 	// Static file serving
 	router.Static("/web", "./web")
-	router.GET("/", func(c *gin.Context) {
-		c.Redirect(http.StatusMovedPermanently, "/web/")
-	})
 }
 
 // Helper function to check if user is authenticated

internal/domains/testing/application/complete_test_run.go

@@ -48,10 +48,18 @@ func (h *CompleteTestRunHandler) Handle(ctx context.Context, cmd CompleteTestRun
 
 	// Complete the test run
 	now := time.Now()
+	// Always set EndTime and Status
 	testRun.EndTime = &now
 	testRun.Status = "completed"
-	if testRun.StartTime.After(time.Time{}) {
-		testRun.Duration = now.Sub(testRun.StartTime)
+
+	// If StartTime is zero, set it to now (fallback)
+	if testRun.StartTime.IsZero() {
+		testRun.StartTime = now
+	}
+
+	// Calculate duration if both times are set
+	if testRun.EndTime != nil && !testRun.StartTime.IsZero() {
+		testRun.Duration = testRun.EndTime.Sub(testRun.StartTime)
 	}
 
 	// Update flaky test statistics

internal/domains/testing/application/complete_test_run_test.go

@@ -0,0 +1,106 @@
+package application_test
+
+import (
+	"context"
+	"time"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/stretchr/testify/mock"
+
+	"github.com/guidewire-oss/fern-platform/internal/domains/testing/application"
+	"github.com/guidewire-oss/fern-platform/internal/domains/testing/domain"
+)
+
+type mockTestRunRepo struct{ mock.Mock }
+
+func (m *mockTestRunRepo) Create(ctx context.Context, testRun *domain.TestRun) error { return nil }
+func (m *mockTestRunRepo) GetByID(ctx context.Context, id uint) (*domain.TestRun, error) {
+	return nil, nil
+}
+func (m *mockTestRunRepo) GetWithDetails(ctx context.Context, id uint) (*domain.TestRun, error) {
+	return nil, nil
+}
+func (m *mockTestRunRepo) GetLatestByProjectID(ctx context.Context, projectID string, limit int) ([]*domain.TestRun, error) {
+	return nil, nil
+}
+func (m *mockTestRunRepo) GetTestRunSummary(ctx context.Context, projectID string) (*domain.TestRunSummary, error) {
+	return nil, nil
+}
+func (m *mockTestRunRepo) Delete(ctx context.Context, id uint) error { return nil }
+func (m *mockTestRunRepo) CountByProjectID(ctx context.Context, projectID string) (int64, error) {
+	return 0, nil
+}
+func (m *mockTestRunRepo) GetRecent(ctx context.Context, limit int) ([]*domain.TestRun, error) {
+	return nil, nil
+}
+func (m *mockTestRunRepo) GetByRunID(ctx context.Context, runID string) (*domain.TestRun, error) {
+	args := m.Called(ctx, runID)
+	return args.Get(0).(*domain.TestRun), args.Error(1)
+}
+func (m *mockTestRunRepo) Update(ctx context.Context, tr *domain.TestRun) error {
+	args := m.Called(ctx, tr)
+	return args.Error(0)
+}
+
+type mockFlakyRepo struct{ mock.Mock }
+
+func (m *mockFlakyRepo) Save(ctx context.Context, flakyTest *domain.FlakyTest) error { return nil }
+func (m *mockFlakyRepo) FindByProject(ctx context.Context, projectID string) ([]*domain.FlakyTest, error) {
+	return nil, nil
+}
+func (m *mockFlakyRepo) FindByTestName(ctx context.Context, projectID, testName string) (*domain.FlakyTest, error) {
+	return nil, nil
+}
+func (m *mockFlakyRepo) Update(ctx context.Context, flakyTest *domain.FlakyTest) error { return nil }
+
+// Note: Suite entry point defined in test_run_service_test.go (TestApplication)
+
+var _ = Describe("CompleteTestRunHandler", Label("unit", "application"), func() {
+	var (
+		mockRepo  *mockTestRunRepo
+		mockFlaky *mockFlakyRepo
+		handler   *application.CompleteTestRunHandler
+	)
+
+	BeforeEach(func() {
+		mockRepo = new(mockTestRunRepo)
+		mockFlaky = new(mockFlakyRepo)
+		handler = application.NewCompleteTestRunHandler(mockRepo, mockFlaky)
+	})
+
+	Describe("Handle", func() {
+		Context("when test run exists", func() {
+			It("should complete the test run successfully", func() {
+				tr := &domain.TestRun{RunID: "run-1", StartTime: time.Now().Add(-time.Hour)}
+				mockRepo.On("GetByRunID", mock.Anything, "run-1").Return(tr, nil)
+				mockRepo.On("Update", mock.Anything, tr).Return(nil)
+
+				err := handler.Handle(context.Background(), application.CompleteTestRunCommand{RunID: "run-1"})
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(tr.Status).To(Equal("completed"))
+				Expect(tr.EndTime).ToNot(BeNil())
+				Expect(tr.Duration).To(BeNumerically(">", 0))
+			})
+		})
+
+		Context("when test run is not found", func() {
+			It("should return an error", func() {
+				mockRepo.On("GetByRunID", mock.Anything, "run-x").Return((*domain.TestRun)(nil), nil)
+
+				err := handler.Handle(context.Background(), application.CompleteTestRunCommand{RunID: "run-x"})
+
+				Expect(err).To(HaveOccurred())
+			})
+		})
+
+		Context("when run ID is empty", func() {
+			It("should return an error", func() {
+				err := handler.Handle(context.Background(), application.CompleteTestRunCommand{RunID: ""})
+
+				Expect(err).To(HaveOccurred())
+			})
+		})
+	})
+})

internal/domains/testing/application/test_run_service.go

@@ -180,6 +180,19 @@ func (s *TestRunService) updateSuiteStatistics(ctx context.Context, suiteRunID u
 
 	for _, spec := range specRuns {
 		totalTests++
+		// Fallback: If EndTime is nil, set to now
+		if spec.EndTime == nil {
+			now := time.Now()
+			spec.EndTime = &now
+		}
+		// Fallback: If StartTime is zero, set to EndTime
+		if spec.StartTime.IsZero() && spec.EndTime != nil {
+			spec.StartTime = *spec.EndTime
+		}
+		// Calculate duration if missing
+		if spec.Duration == 0 && spec.EndTime != nil && !spec.StartTime.IsZero() {
+			spec.Duration = spec.EndTime.Sub(spec.StartTime)
+		}
 		totalDuration += spec.Duration
 
 		switch spec.Status {
@@ -260,6 +273,10 @@ func (s *TestRunService) CreateSuiteRun(ctx context.Context, suiteRun *domain.Su
 	if suiteRun.Status == "" {
 		suiteRun.Status = "running"
 	}
+	// Always set StartTime if zero
+	if suiteRun.StartTime.IsZero() {
+		suiteRun.StartTime = time.Now()
+	}
 
 	return s.suiteRunRepo.Create(ctx, suiteRun)
 }
@@ -274,10 +291,17 @@ func (s *TestRunService) CreateSpecRun(ctx context.Context, specRun *domain.Spec
 	if specRun.Status == "" {
 		specRun.Status = "pending"
 	}
+	
+	// Only auto-set StartTime if both StartTime and EndTime are zero
+	if specRun.StartTime.IsZero() && (specRun.EndTime == nil || specRun.EndTime.IsZero()) {
+		specRun.StartTime = time.Now()
+	}
 
-	// Calculate duration if not set
-	if specRun.EndTime != nil && !specRun.StartTime.IsZero() {
-		specRun.Duration = specRun.EndTime.Sub(specRun.StartTime)
+	// Calculate duration only if both times are set and EndTime is after StartTime
+	if specRun.EndTime != nil && !specRun.StartTime.IsZero() && !specRun.EndTime.IsZero() {
+		if specRun.EndTime.After(specRun.StartTime) {
+			specRun.Duration = specRun.EndTime.Sub(specRun.StartTime)
+		}
 	}
 
 	return s.specRunRepo.Create(ctx, specRun)