package services import ( "github.com/muety/wakapi/mocks" "github.com/muety/wakapi/models" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/suite" "math/rand" "strings" "testing" "time" ) const ( TestProjectLabel1 = "private" TestProjectLabel2 = "work" TestProjectLabel3 = "non-existing" ) type SummaryServiceTestSuite struct { suite.Suite TestUser *models.User TestStartTime time.Time TestDurations []*models.Duration TestLabels []*models.ProjectLabel SummaryRepository *mocks.SummaryRepositoryMock DurationService *mocks.DurationServiceMock AliasService *mocks.AliasServiceMock ProjectLabelService *mocks.ProjectLabelServiceMock } func (suite *SummaryServiceTestSuite) SetupSuite() { suite.TestUser = &models.User{ID: TestUserId} suite.TestStartTime = time.Unix(0, MinUnixTime1) suite.TestDurations = []*models.Duration{ { UserID: TestUserId, Project: TestProject1, Language: TestLanguageGo, Editor: TestEditorGoland, OperatingSystem: TestOsLinux, Machine: TestMachine1, Branch: TestBranchMaster, Entity: TestEntity1, Time: models.CustomTime(suite.TestStartTime), Duration: 150 * time.Second, NumHeartbeats: 2, }, { UserID: TestUserId, Project: TestProject1, Language: TestLanguageGo, Editor: TestEditorGoland, OperatingSystem: TestOsLinux, Machine: TestMachine1, Branch: TestBranchMaster, Entity: TestEntity1, Time: models.CustomTime(suite.TestStartTime.Add((30 + 130) * time.Second)), Duration: 20 * time.Second, NumHeartbeats: 1, }, { UserID: TestUserId, Project: TestProject1, Language: TestLanguageGo, Editor: TestEditorVscode, OperatingSystem: TestOsLinux, Machine: TestMachine1, Branch: TestBranchDev, Entity: TestEntity1, Time: models.CustomTime(suite.TestStartTime.Add(3 * time.Minute)), Duration: 15 * time.Second, NumHeartbeats: 3, }, } suite.TestLabels = []*models.ProjectLabel{ { ID: uint(rand.Uint32()), UserID: TestUserId, ProjectKey: TestProject1, Label: TestProjectLabel1, }, { ID: uint(rand.Uint32()), UserID: TestUserId, ProjectKey: TestProject3, Label: TestProjectLabel3, }, } } func (suite *SummaryServiceTestSuite) BeforeTest(suiteName, testName string) { suite.SummaryRepository = new(mocks.SummaryRepositoryMock) suite.DurationService = new(mocks.DurationServiceMock) suite.AliasService = new(mocks.AliasServiceMock) suite.ProjectLabelService = new(mocks.ProjectLabelServiceMock) } func TestSummaryServiceTestSuite(t *testing.T) { suite.Run(t, new(SummaryServiceTestSuite)) } func (suite *SummaryServiceTestSuite) TestSummaryService_Summarize() { sut := NewSummaryService(suite.SummaryRepository, suite.DurationService, suite.AliasService, suite.ProjectLabelService) var ( from time.Time to time.Time result *models.Summary err error ) /* TEST 1 */ from, to = suite.TestStartTime.Add(-1*time.Hour), suite.TestStartTime.Add(-1*time.Minute) suite.DurationService.On("Get", from, to, suite.TestUser, mock.Anything).Return(filterDurations(from, to, suite.TestDurations), nil) result, err = sut.Summarize(from, to, suite.TestUser, nil) assert.Nil(suite.T(), err) assert.NotNil(suite.T(), result) assert.Equal(suite.T(), from, result.FromTime.T()) assert.Equal(suite.T(), to, result.ToTime.T()) assert.Zero(suite.T(), result.TotalTime()) assert.Zero(suite.T(), result.NumHeartbeats) assert.Empty(suite.T(), result.Projects) /* TEST 2 */ from, to = suite.TestStartTime.Add(-1*time.Hour), suite.TestStartTime.Add(1*time.Second) suite.DurationService.On("Get", from, to, suite.TestUser, mock.Anything).Return(filterDurations(from, to, suite.TestDurations), nil) result, err = sut.Summarize(from, to, suite.TestUser, nil) assert.Nil(suite.T(), err) assert.NotNil(suite.T(), result) assert.Equal(suite.T(), suite.TestDurations[0].Time.T(), result.FromTime.T()) assert.Equal(suite.T(), suite.TestDurations[0].Time.T(), result.ToTime.T()) assert.Equal(suite.T(), 150*time.Second, result.TotalTime()) assert.Equal(suite.T(), 2, result.NumHeartbeats) assertNumAllItems(suite.T(), 1, result, "") /* TEST 3 */ from, to = suite.TestStartTime, suite.TestStartTime.Add(1*time.Hour) suite.DurationService.On("Get", from, to, suite.TestUser, mock.Anything).Return(filterDurations(from, to, suite.TestDurations), nil) result, err = sut.Summarize(from, to, suite.TestUser, nil) assert.Nil(suite.T(), err) assert.NotNil(suite.T(), result) assert.Equal(suite.T(), suite.TestDurations[0].Time.T(), result.FromTime.T()) assert.Equal(suite.T(), suite.TestDurations[len(suite.TestDurations)-1].Time.T(), result.ToTime.T()) assert.Equal(suite.T(), 185*time.Second, result.TotalTime()) assert.Equal(suite.T(), 185*time.Second, result.TotalTimeBy(models.SummaryProject)) assert.Equal(suite.T(), 185*time.Second, result.TotalTimeBy(models.SummaryOS)) assert.Equal(suite.T(), 185*time.Second, result.TotalTimeBy(models.SummaryMachine)) assert.Equal(suite.T(), 185*time.Second, result.TotalTimeBy(models.SummaryLanguage)) assert.Equal(suite.T(), 185*time.Second, result.TotalTimeBy(models.SummaryEditor)) assert.Zero(suite.T(), result.TotalTimeBy(models.SummaryBranch)) // no filters -> no branches contained assert.Zero(suite.T(), result.TotalTimeBy(models.SummaryEntity)) // no filters -> no entities contained assert.Zero(suite.T(), result.TotalTimeBy(models.SummaryLabel)) assert.Equal(suite.T(), 170*time.Second, result.TotalTimeByKey(models.SummaryEditor, TestEditorGoland)) assert.Equal(suite.T(), 15*time.Second, result.TotalTimeByKey(models.SummaryEditor, TestEditorVscode)) assert.Equal(suite.T(), 6, result.NumHeartbeats) assert.Len(suite.T(), result.Editors, 2) assertNumAllItems(suite.T(), 1, result, "e") } func (suite *SummaryServiceTestSuite) TestSummaryService_Retrieve() { sut := NewSummaryService(suite.SummaryRepository, suite.DurationService, suite.AliasService, suite.ProjectLabelService) var ( summaries []*models.Summary from time.Time to time.Time result *models.Summary err error ) /* TEST 1 */ from, to = suite.TestStartTime.Add(-12*time.Hour), suite.TestStartTime.Add(12*time.Hour) summaries = []*models.Summary{ { ID: uint(rand.Uint32()), UserID: TestUserId, FromTime: models.CustomTime(from.Add(10 * time.Minute)), ToTime: models.CustomTime(to.Add(-10 * time.Minute)), Projects: []*models.SummaryItem{ { Type: models.SummaryProject, Key: TestProject1, Total: 45 * time.Minute / time.Second, // hack }, }, Languages: []*models.SummaryItem{}, Editors: []*models.SummaryItem{}, OperatingSystems: []*models.SummaryItem{}, Machines: []*models.SummaryItem{}, NumHeartbeats: 100, }, } suite.SummaryRepository.On("GetByUserWithin", suite.TestUser, from, to).Return(summaries, nil) suite.DurationService.On("Get", from, summaries[0].FromTime.T(), suite.TestUser, mock.Anything).Return(models.Durations{}, nil) suite.DurationService.On("Get", summaries[0].ToTime.T(), to, suite.TestUser, mock.Anything).Return(models.Durations{}, nil) result, err = sut.Retrieve(from, to, suite.TestUser, nil) assert.Nil(suite.T(), err) assert.NotNil(suite.T(), result) assert.Len(suite.T(), result.Projects, 1) assert.Equal(suite.T(), summaries[0].Projects[0].Total*time.Second, result.TotalTime()) assert.Equal(suite.T(), 100, result.NumHeartbeats) suite.DurationService.AssertNumberOfCalls(suite.T(), "Get", 2) /* TEST 2 */ from, to = suite.TestStartTime.Add(-10*time.Minute), suite.TestStartTime.Add(12*time.Hour) summaries = []*models.Summary{ { ID: uint(rand.Uint32()), UserID: TestUserId, FromTime: models.CustomTime(from.Add(20 * time.Minute)), ToTime: models.CustomTime(to.Add(-6 * time.Hour)), Projects: []*models.SummaryItem{ { Type: models.SummaryProject, Key: TestProject1, Total: 45 * time.Minute / time.Second, // hack }, }, Languages: []*models.SummaryItem{}, Editors: []*models.SummaryItem{}, OperatingSystems: []*models.SummaryItem{}, Machines: []*models.SummaryItem{}, NumHeartbeats: 100, }, { ID: uint(rand.Uint32()), UserID: TestUserId, FromTime: models.CustomTime(to.Add(-6 * time.Hour)), ToTime: models.CustomTime(to), Projects: []*models.SummaryItem{ { Type: models.SummaryProject, Key: TestProject2, Total: 45 * time.Minute / time.Second, // hack }, }, Languages: []*models.SummaryItem{}, Editors: []*models.SummaryItem{}, OperatingSystems: []*models.SummaryItem{}, Machines: []*models.SummaryItem{}, NumHeartbeats: 100, }, } suite.SummaryRepository.On("GetByUserWithin", suite.TestUser, from, to).Return(summaries, nil) suite.DurationService.On("Get", from, summaries[0].FromTime.T(), suite.TestUser, mock.Anything).Return(filterDurations(from, summaries[0].FromTime.T(), suite.TestDurations), nil) result, err = sut.Retrieve(from, to, suite.TestUser, nil) assert.Nil(suite.T(), err) assert.NotNil(suite.T(), result) assert.Len(suite.T(), result.Projects, 2) assert.Equal(suite.T(), 185*time.Second+90*time.Minute, result.TotalTime()) assert.Equal(suite.T(), 185*time.Second+45*time.Minute, result.TotalTimeByKey(models.SummaryProject, TestProject1)) assert.Equal(suite.T(), 45*time.Minute, result.TotalTimeByKey(models.SummaryProject, TestProject2)) assert.Equal(suite.T(), 206, result.NumHeartbeats) suite.DurationService.AssertNumberOfCalls(suite.T(), "Get", 2+1) /* TEST 3 */ from = time.Date(suite.TestStartTime.Year(), suite.TestStartTime.Month(), suite.TestStartTime.Day()+1, 0, 0, 0, 0, suite.TestStartTime.Location()) // start of next day to = time.Date(from.Year(), from.Month(), from.Day()+2, 13, 30, 0, 0, from.Location()) // noon of third-next day summaries = []*models.Summary{ { ID: uint(rand.Uint32()), UserID: TestUserId, FromTime: models.CustomTime(from), ToTime: models.CustomTime(from.Add(24 * time.Hour)), Projects: []*models.SummaryItem{ { Type: models.SummaryProject, Key: TestProject1, Total: 45 * time.Minute / time.Second, // hack }, }, Languages: []*models.SummaryItem{}, Editors: []*models.SummaryItem{}, OperatingSystems: []*models.SummaryItem{}, Machines: []*models.SummaryItem{}, NumHeartbeats: 100, }, { ID: uint(rand.Uint32()), UserID: TestUserId, FromTime: models.CustomTime(to.Add(-2 * time.Hour)), ToTime: models.CustomTime(to), Projects: []*models.SummaryItem{ { Type: models.SummaryProject, Key: TestProject2, Total: 45 * time.Minute / time.Second, // hack }, }, Languages: []*models.SummaryItem{}, Editors: []*models.SummaryItem{}, OperatingSystems: []*models.SummaryItem{}, Machines: []*models.SummaryItem{}, NumHeartbeats: 100, }, } suite.SummaryRepository.On("GetByUserWithin", suite.TestUser, from, to).Return(summaries, nil) suite.DurationService.On("Get", summaries[0].ToTime.T(), summaries[1].FromTime.T(), suite.TestUser, mock.Anything).Return(filterDurations(summaries[0].ToTime.T(), summaries[1].FromTime.T(), suite.TestDurations), nil) result, err = sut.Retrieve(from, to, suite.TestUser, nil) assert.Nil(suite.T(), err) assert.NotNil(suite.T(), result) assert.Len(suite.T(), result.Projects, 2) assert.Equal(suite.T(), 90*time.Minute, result.TotalTime()) assert.Equal(suite.T(), 45*time.Minute, result.TotalTimeByKey(models.SummaryProject, TestProject1)) assert.Equal(suite.T(), 45*time.Minute, result.TotalTimeByKey(models.SummaryProject, TestProject2)) assert.Equal(suite.T(), 200, result.NumHeartbeats) suite.DurationService.AssertNumberOfCalls(suite.T(), "Get", 2+1) } func (suite *SummaryServiceTestSuite) TestSummaryService_Retrieve_DuplicateSummaries() { sut := NewSummaryService(suite.SummaryRepository, suite.DurationService, suite.AliasService, suite.ProjectLabelService) suite.ProjectLabelService.On("GetByUser", suite.TestUser.ID).Return([]*models.ProjectLabel{}, nil) var ( summaries []*models.Summary from time.Time to time.Time result *models.Summary err error ) from, to = suite.TestStartTime.Add(-12*time.Hour), suite.TestStartTime.Add(12*time.Hour) summaries = []*models.Summary{ { ID: uint(rand.Uint32()), UserID: TestUserId, FromTime: models.CustomTime(from.Add(10 * time.Minute)), ToTime: models.CustomTime(to.Add(-10 * time.Minute)), Projects: []*models.SummaryItem{ { Type: models.SummaryProject, Key: TestProject1, Total: 45 * time.Minute / time.Second, // hack }, }, Languages: []*models.SummaryItem{}, Editors: []*models.SummaryItem{}, OperatingSystems: []*models.SummaryItem{}, Machines: []*models.SummaryItem{}, }, } summaries = append(summaries, &(*summaries[0])) // add same summary again -> mustn't be counted twice! suite.SummaryRepository.On("GetByUserWithin", suite.TestUser, from, to).Return(summaries, nil) suite.DurationService.On("Get", from, summaries[0].FromTime.T(), suite.TestUser, mock.Anything).Return(models.Durations{}, nil) suite.DurationService.On("Get", summaries[0].ToTime.T(), to, suite.TestUser, mock.Anything).Return(models.Durations{}, nil) result, err = sut.Retrieve(from, to, suite.TestUser, nil) assert.Nil(suite.T(), err) assert.NotNil(suite.T(), result) assert.Len(suite.T(), result.Projects, 1) assert.Equal(suite.T(), summaries[0].Projects[0].Total*time.Second, result.TotalTime()) suite.DurationService.AssertNumberOfCalls(suite.T(), "Get", 2) } func (suite *SummaryServiceTestSuite) TestSummaryService_Aliased() { sut := NewSummaryService(suite.SummaryRepository, suite.DurationService, suite.AliasService, suite.ProjectLabelService) suite.AliasService.On("InitializeUser", suite.TestUser.ID).Return(nil) suite.ProjectLabelService.On("GetByUser", suite.TestUser.ID).Return([]*models.ProjectLabel{}, nil) var ( from time.Time to time.Time result *models.Summary err error ) from, to = suite.TestStartTime, suite.TestStartTime.Add(1*time.Hour) durations := filterDurations(from, to, suite.TestDurations) durations = append(durations, &models.Duration{ UserID: TestUserId, Project: TestProject2, Language: TestLanguageGo, Editor: TestEditorGoland, OperatingSystem: TestOsLinux, Machine: TestMachine1, Time: models.CustomTime(durations[len(durations)-1].Time.T().Add(10 * time.Second)), Duration: 0, // not relevant here }) suite.DurationService.On("Get", from, to, suite.TestUser, mock.Anything).Return(durations, nil) suite.AliasService.On("InitializeUser", TestUserId).Return(nil) suite.AliasService.On("GetAliasOrDefault", TestUserId, mock.Anything, TestProject1).Return(TestProject2, nil) suite.AliasService.On("GetAliasOrDefault", TestUserId, mock.Anything, TestProject2).Return(TestProject2, nil) suite.AliasService.On("GetAliasOrDefault", TestUserId, mock.Anything, mock.Anything).Return("", nil) suite.ProjectLabelService.On("GetByUser", suite.TestUser.ID).Return(suite.TestLabels, nil).Once() result, err = sut.Aliased(from, to, suite.TestUser, sut.Summarize, nil, false) assert.Nil(suite.T(), err) assert.NotNil(suite.T(), result) assert.Zero(suite.T(), result.TotalTimeByKey(models.SummaryProject, TestProject1)) assert.NotZero(suite.T(), result.TotalTimeByKey(models.SummaryProject, TestProject2)) assert.Equal(suite.T(), 6, result.NumHeartbeats) assert.Nil(suite.T(), result.Branches) } func (suite *SummaryServiceTestSuite) TestSummaryService_Aliased_ProjectLabels() { sut := NewSummaryService(suite.SummaryRepository, suite.DurationService, suite.AliasService, suite.ProjectLabelService) var ( from time.Time to time.Time result *models.Summary err error ) from, to = suite.TestStartTime, suite.TestStartTime.Add(1*time.Hour) durations := filterDurations(from, to, suite.TestDurations) durations = append(durations, &models.Duration{ UserID: TestUserId, Project: TestProject2, Language: TestLanguageGo, Editor: TestEditorGoland, OperatingSystem: TestOsLinux, Machine: TestMachine1, Time: models.CustomTime(durations[len(durations)-1].Time.T().Add(10 * time.Second)), Duration: 10 * time.Second, }) suite.ProjectLabelService.On("GetByUser", suite.TestUser.ID).Return(suite.TestLabels, nil).Once() suite.DurationService.On("Get", from, to, suite.TestUser, mock.Anything).Return(models.Durations(durations), nil) suite.AliasService.On("InitializeUser", TestUserId).Return(nil) suite.AliasService.On("GetAliasOrDefault", TestUserId, mock.Anything, TestProject1).Return(TestProject1, nil) suite.AliasService.On("GetAliasOrDefault", TestUserId, mock.Anything, TestProject2).Return(TestProject1, nil) suite.AliasService.On("GetAliasOrDefault", TestUserId, mock.Anything, mock.Anything).Return("", nil) result, err = sut.Aliased(from, to, suite.TestUser, sut.Summarize, nil, false) assert.Nil(suite.T(), err) assert.NotNil(suite.T(), result) assert.Equal(suite.T(), 195*time.Second, result.TotalTimeByKey(models.SummaryLabel, TestProjectLabel1)) assert.Equal(suite.T(), 6, result.NumHeartbeats) } func (suite *SummaryServiceTestSuite) TestSummaryService_Filters() { sut := NewSummaryService(suite.SummaryRepository, suite.DurationService, suite.AliasService, suite.ProjectLabelService) suite.AliasService.On("InitializeUser", suite.TestUser.ID).Return(nil) suite.ProjectLabelService.On("GetByUser", suite.TestUser.ID).Return([]*models.ProjectLabel{}, nil) from, to := suite.TestStartTime, suite.TestStartTime.Add(1*time.Hour) filters := models.NewFiltersWith(models.SummaryProject, TestProject1).With(models.SummaryLabel, TestProjectLabel3) suite.DurationService.On("Get", from, to, suite.TestUser, mock.Anything).Return(models.Durations{}, nil) suite.AliasService.On("InitializeUser", TestUserId).Return(nil) suite.AliasService.On("GetByUserAndKeyAndType", TestUserId, TestProject1, models.SummaryProject).Return([]*models.Alias{ { Type: models.SummaryProject, Key: TestProject1, Value: TestProject2, }, }, nil) suite.ProjectLabelService.On("GetByUserGroupedInverted", suite.TestUser.ID).Return(map[string][]*models.ProjectLabel{ suite.TestLabels[0].Label: suite.TestLabels[0:1], suite.TestLabels[1].Label: suite.TestLabels[1:2], }, nil).Once() result, _ := sut.Aliased(from, to, suite.TestUser, sut.Summarize, filters, false) assert.NotNil(suite.T(), result.Branches) // project filters were applied -> include branches assert.NotNil(suite.T(), result.Entities) // project filters were applied -> include entities effectiveFilters := suite.DurationService.Calls[0].Arguments[3].(*models.Filters) assert.Contains(suite.T(), effectiveFilters.Project, TestProject1) // because actually requested assert.Contains(suite.T(), effectiveFilters.Project, TestProject2) // because of alias assert.Contains(suite.T(), effectiveFilters.Project, TestProject3) // because of label assert.Contains(suite.T(), effectiveFilters.Label, TestProjectLabel3) } func (suite *SummaryServiceTestSuite) TestSummaryService_getMissingIntervals() { sut := NewSummaryService(suite.SummaryRepository, suite.DurationService, suite.AliasService, suite.ProjectLabelService) from1, _ := time.Parse(time.RFC822, "25 Mar 22 11:00 UTC") to1, _ := time.Parse(time.RFC822, "25 Mar 22 13:00 UTC") from2, _ := time.Parse(time.RFC822, "25 Mar 22 15:00 UTC") to2, _ := time.Parse(time.RFC822, "26 Mar 22 00:00 UTC") summaries := []*models.Summary{ {FromTime: models.CustomTime(from1), ToTime: models.CustomTime(to1)}, {FromTime: models.CustomTime(from2), ToTime: models.CustomTime(to2)}, } r1 := sut.getMissingIntervals(from1, to1, summaries, true) assert.Empty(suite.T(), r1) r2 := sut.getMissingIntervals(from1, from1, summaries, true) assert.Empty(suite.T(), r2) // non-precise mode will not return intra-day intervals // we might want to change this ... r3 := sut.getMissingIntervals(from1, to2, summaries, false) assert.Len(suite.T(), r3, 0) r4 := sut.getMissingIntervals(from1, to2, summaries, true) assert.Len(suite.T(), r4, 1) assert.Equal(suite.T(), to1, r4[0].Start) assert.Equal(suite.T(), from2, r4[0].End) r5 := sut.getMissingIntervals(from1.Add(-time.Hour), to2.Add(time.Hour), summaries, true) assert.Len(suite.T(), r5, 3) assert.Equal(suite.T(), from1.Add(-time.Hour), r5[0].Start) assert.Equal(suite.T(), from1, r5[0].End) assert.Equal(suite.T(), to1, r5[1].Start) assert.Equal(suite.T(), from2, r5[1].End) assert.Equal(suite.T(), to2, r5[2].Start) assert.Equal(suite.T(), to2.Add(time.Hour), r5[2].End) } func filterDurations(from, to time.Time, durations models.Durations) models.Durations { filtered := make([]*models.Duration, 0, len(durations)) for _, d := range durations { if (d.Time.T().Equal(from) || d.Time.T().After(from)) && d.Time.T().Before(to) { filtered = append(filtered, d) } } return filtered } func assertNumAllItems(t *testing.T, expected int, summary *models.Summary, except string) { if !strings.Contains(except, "p") { assert.Len(t, summary.Projects, expected) } if !strings.Contains(except, "e") { assert.Len(t, summary.Editors, expected) } if !strings.Contains(except, "l") { assert.Len(t, summary.Languages, expected) } if !strings.Contains(except, "o") { assert.Len(t, summary.OperatingSystems, expected) } if !strings.Contains(except, "m") { assert.Len(t, summary.Machines, expected) } }