github.com/justinjmoses/evergreen@v0.0.0-20170530173719-1d50e381ff0d/scheduler/task_priority_cmp_test.go (about)

     1  package scheduler
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/evergreen-ci/evergreen"
     8  	"github.com/evergreen-ci/evergreen/db"
     9  	"github.com/evergreen-ci/evergreen/model/task"
    10  	"github.com/evergreen-ci/evergreen/testutil"
    11  	"github.com/mongodb/grip"
    12  	. "github.com/smartystreets/goconvey/convey"
    13  )
    14  
    15  var taskImportanceCmpTestConf = testutil.TestConfig()
    16  
    17  func init() {
    18  	db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(taskImportanceCmpTestConf))
    19  	grip.CatchError(grip.SetSender(testutil.SetupTestSender(taskImportanceCmpTestConf.Scheduler.LogFile)))
    20  }
    21  
    22  func TestTaskImportanceComparators(t *testing.T) {
    23  
    24  	var taskComparator *CmpBasedTaskComparator
    25  	var taskIds []string
    26  	var tasks []task.Task
    27  
    28  	Convey("When using the task importance comparators", t, func() {
    29  
    30  		taskComparator = &CmpBasedTaskComparator{}
    31  
    32  		taskIds = []string{"t1", "t2"}
    33  
    34  		tasks = []task.Task{
    35  			{Id: taskIds[0]},
    36  			{Id: taskIds[1]},
    37  		}
    38  
    39  		Convey("the explicit priority comparator should prioritize a task"+
    40  			" if its priority is higher", func() {
    41  
    42  			tasks[0].Priority = 2
    43  			tasks[1].Priority = 2
    44  
    45  			cmpResult, err := byPriority(tasks[0], tasks[1], taskComparator)
    46  			So(err, ShouldBeNil)
    47  			So(cmpResult, ShouldEqual, 0)
    48  
    49  			tasks[0].Priority = 2
    50  			tasks[1].Priority = 1
    51  			cmpResult, err = byPriority(tasks[0], tasks[1], taskComparator)
    52  			So(err, ShouldBeNil)
    53  			So(cmpResult, ShouldEqual, 1)
    54  
    55  			tasks[0].Priority = 1
    56  			tasks[1].Priority = 2
    57  			cmpResult, err = byPriority(tasks[0], tasks[1], taskComparator)
    58  			So(err, ShouldBeNil)
    59  			So(cmpResult, ShouldEqual, -1)
    60  		})
    61  
    62  		Convey("the dependent count comparator should prioritize a task"+
    63  			" if its number of dependents is higher", func() {
    64  
    65  			cmpResult, err := byNumDeps(tasks[0], tasks[1],
    66  				taskComparator)
    67  			So(err, ShouldBeNil)
    68  			So(cmpResult, ShouldEqual, 0)
    69  
    70  			tasks[0].NumDependents = 1
    71  			cmpResult, err = byNumDeps(tasks[0], tasks[1],
    72  				taskComparator)
    73  			So(err, ShouldBeNil)
    74  			So(cmpResult, ShouldEqual, 1)
    75  
    76  			cmpResult, err = byNumDeps(tasks[1], tasks[0],
    77  				taskComparator)
    78  			So(err, ShouldBeNil)
    79  			So(cmpResult, ShouldEqual, -1)
    80  
    81  			tasks[1].NumDependents = 1
    82  			cmpResult, err = byNumDeps(tasks[0], tasks[1],
    83  				taskComparator)
    84  			So(err, ShouldBeNil)
    85  			So(cmpResult, ShouldEqual, 0)
    86  
    87  		})
    88  
    89  		Convey("the commit order number comparator should prioritize a task"+
    90  			" whose commit order number is higher, providing the tasks are"+
    91  			" part of the same project", func() {
    92  
    93  			cmpResult, err := byRevisionOrderNumber(tasks[0], tasks[1],
    94  				taskComparator)
    95  			So(err, ShouldBeNil)
    96  			So(cmpResult, ShouldEqual, 0)
    97  
    98  			tasks[0].RevisionOrderNumber = 1
    99  			cmpResult, err = byRevisionOrderNumber(tasks[0], tasks[1],
   100  				taskComparator)
   101  			So(err, ShouldBeNil)
   102  			So(cmpResult, ShouldEqual, 1)
   103  
   104  			cmpResult, err = byRevisionOrderNumber(tasks[1], tasks[0],
   105  				taskComparator)
   106  			So(err, ShouldBeNil)
   107  			So(cmpResult, ShouldEqual, -1)
   108  
   109  			tasks[0].Project = "project"
   110  			cmpResult, err = byRevisionOrderNumber(tasks[0], tasks[1],
   111  				taskComparator)
   112  			So(err, ShouldBeNil)
   113  			So(cmpResult, ShouldEqual, 0)
   114  
   115  		})
   116  
   117  		Convey("the create time comparator should prioritize a task whose"+
   118  			" create time is higher, providing the tasks are from different"+
   119  			" projects", func() {
   120  
   121  			cmpResult, err := byCreateTime(tasks[0], tasks[1], taskComparator)
   122  			So(err, ShouldBeNil)
   123  			So(cmpResult, ShouldEqual, 0)
   124  
   125  			// change one create time - should still be zero since the
   126  			// projects are the same
   127  			tasks[0].CreateTime = time.Now()
   128  			cmpResult, err = byCreateTime(tasks[0], tasks[1], taskComparator)
   129  			So(err, ShouldBeNil)
   130  			So(cmpResult, ShouldEqual, 0)
   131  
   132  			tasks[0].Project = "project"
   133  			cmpResult, err = byCreateTime(tasks[0], tasks[1], taskComparator)
   134  			So(err, ShouldBeNil)
   135  			So(cmpResult, ShouldEqual, 1)
   136  
   137  			cmpResult, err = byCreateTime(tasks[1], tasks[0], taskComparator)
   138  			So(err, ShouldBeNil)
   139  			So(cmpResult, ShouldEqual, -1)
   140  
   141  			tasks[1].CreateTime = tasks[0].CreateTime
   142  			cmpResult, err = byCreateTime(tasks[0], tasks[1], taskComparator)
   143  			So(err, ShouldBeNil)
   144  			So(cmpResult, ShouldEqual, 0)
   145  
   146  			cmpResult, err = byCreateTime(tasks[1], tasks[0], taskComparator)
   147  			So(err, ShouldBeNil)
   148  			So(cmpResult, ShouldEqual, 0)
   149  
   150  		})
   151  
   152  		Convey("the recent failure comparator should prioritize a task"+
   153  			" whose last execution failed", func() {
   154  
   155  			prevTaskIds := []string{"pt1", "pt2"}
   156  
   157  			prevTasks := map[string]task.Task{
   158  				taskIds[0]: {Id: prevTaskIds[0]},
   159  				taskIds[1]: {Id: prevTaskIds[1]},
   160  			}
   161  
   162  			taskComparator.previousTasksCache = prevTasks
   163  
   164  			cmpResult, err := byRecentlyFailing(tasks[0], tasks[1],
   165  				taskComparator)
   166  			So(err, ShouldBeNil)
   167  			So(cmpResult, ShouldEqual, 0)
   168  
   169  			pt1 := taskComparator.previousTasksCache[taskIds[0]]
   170  			pt1.Status = evergreen.TaskFailed
   171  			taskComparator.previousTasksCache[taskIds[0]] = pt1
   172  
   173  			cmpResult, err = byRecentlyFailing(tasks[0], tasks[1],
   174  				taskComparator)
   175  			So(err, ShouldBeNil)
   176  			So(cmpResult, ShouldEqual, 1)
   177  
   178  			cmpResult, err = byRecentlyFailing(tasks[1], tasks[0],
   179  				taskComparator)
   180  			So(err, ShouldBeNil)
   181  			So(cmpResult, ShouldEqual, -1)
   182  
   183  			pt2 := taskComparator.previousTasksCache[taskIds[1]]
   184  			pt2.Status = evergreen.TaskFailed
   185  			taskComparator.previousTasksCache[taskIds[1]] = pt2
   186  
   187  			cmpResult, err = byRecentlyFailing(tasks[0], tasks[1],
   188  				taskComparator)
   189  			So(err, ShouldBeNil)
   190  			So(cmpResult, ShouldEqual, 0)
   191  
   192  		})
   193  
   194  		Convey("the similar failing comparator should prioritize a task if "+
   195  			"it has more similar failing tasks", func() {
   196  			prlTaskIds := []string{"t1", "t2"}
   197  
   198  			similarFailingCountMap := map[string]int{
   199  				prlTaskIds[0]: 3,
   200  				prlTaskIds[1]: 3,
   201  			}
   202  
   203  			taskComparator.similarFailingCount = similarFailingCountMap
   204  
   205  			cmpResult, err := bySimilarFailing(tasks[0], tasks[1],
   206  				taskComparator)
   207  			So(err, ShouldBeNil)
   208  			So(cmpResult, ShouldEqual, 0)
   209  
   210  			taskComparator.similarFailingCount[prlTaskIds[0]] = 4
   211  
   212  			cmpResult, err = bySimilarFailing(tasks[0], tasks[1],
   213  				taskComparator)
   214  			So(err, ShouldBeNil)
   215  			So(cmpResult, ShouldEqual, 1)
   216  
   217  			taskComparator.similarFailingCount[prlTaskIds[1]] = 5
   218  			cmpResult, err = bySimilarFailing(tasks[0], tasks[1],
   219  				taskComparator)
   220  			So(err, ShouldBeNil)
   221  			So(cmpResult, ShouldEqual, -1)
   222  
   223  			taskComparator.similarFailingCount[prlTaskIds[0]] = 5
   224  
   225  			cmpResult, err = bySimilarFailing(tasks[0], tasks[1],
   226  				taskComparator)
   227  			So(err, ShouldBeNil)
   228  			So(cmpResult, ShouldEqual, 0)
   229  
   230  		})
   231  	})
   232  
   233  }