github.com/filecoin-project/bacalhau@v0.3.23-0.20230228154132-45c989550ace/pkg/requester/ranking/max_usage_test.go (about)

     1  package ranking
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/filecoin-project/bacalhau/pkg/model"
     8  	"github.com/libp2p/go-libp2p/core/peer"
     9  	"github.com/stretchr/testify/suite"
    10  )
    11  
    12  type MaxUsageNodeRankerSuite struct {
    13  	suite.Suite
    14  	MaxUsageNodeRanker *MaxUsageNodeRanker
    15  	smallPeer          model.NodeInfo
    16  	medPeer            model.NodeInfo
    17  	largePeer          model.NodeInfo
    18  }
    19  
    20  func (s *MaxUsageNodeRankerSuite) SetupSuite() {
    21  	s.smallPeer = model.NodeInfo{
    22  		PeerInfo:        peer.AddrInfo{ID: peer.ID("small")},
    23  		ComputeNodeInfo: model.ComputeNodeInfo{MaxJobRequirements: model.ResourceUsageData{CPU: 1}},
    24  	}
    25  	s.medPeer = model.NodeInfo{
    26  		PeerInfo:        peer.AddrInfo{ID: peer.ID("med")},
    27  		ComputeNodeInfo: model.ComputeNodeInfo{MaxJobRequirements: model.ResourceUsageData{CPU: 2}},
    28  	}
    29  	s.largePeer = model.NodeInfo{
    30  		PeerInfo:        peer.AddrInfo{ID: peer.ID("large")},
    31  		ComputeNodeInfo: model.ComputeNodeInfo{MaxJobRequirements: model.ResourceUsageData{CPU: 3}},
    32  	}
    33  }
    34  
    35  func (s *MaxUsageNodeRankerSuite) SetupTest() {
    36  	s.MaxUsageNodeRanker = NewMaxUsageNodeRanker()
    37  }
    38  
    39  func TestMaxUsageNodeRankerSuite(t *testing.T) {
    40  	suite.Run(t, new(MaxUsageNodeRankerSuite))
    41  }
    42  
    43  func (s *MaxUsageNodeRankerSuite) TestRankNodes_VerySmallJob() {
    44  	job := model.Job{Spec: model.Spec{Resources: model.ResourceUsageConfig{CPU: "0.1"}}}
    45  	nodes := []model.NodeInfo{s.smallPeer, s.medPeer, s.largePeer}
    46  	ranks, err := s.MaxUsageNodeRanker.RankNodes(context.Background(), job, nodes)
    47  	s.NoError(err)
    48  	s.Equal(len(nodes), len(ranks))
    49  	assertEquals(s.T(), ranks, "small", 10)
    50  	assertEquals(s.T(), ranks, "med", 10)
    51  	assertEquals(s.T(), ranks, "large", 10)
    52  }
    53  
    54  func (s *MaxUsageNodeRankerSuite) TestRankNodes_SmallJob() {
    55  	job := model.Job{Spec: model.Spec{Resources: model.ResourceUsageConfig{CPU: "1"}}}
    56  	nodes := []model.NodeInfo{s.smallPeer, s.medPeer, s.largePeer}
    57  	ranks, err := s.MaxUsageNodeRanker.RankNodes(context.Background(), job, nodes)
    58  	s.NoError(err)
    59  	s.Equal(len(nodes), len(ranks))
    60  	assertEquals(s.T(), ranks, "small", 10)
    61  	assertEquals(s.T(), ranks, "med", 10)
    62  	assertEquals(s.T(), ranks, "large", 10)
    63  }
    64  
    65  func (s *MaxUsageNodeRankerSuite) TestRankNodes_MedJob() {
    66  	job := model.Job{Spec: model.Spec{Resources: model.ResourceUsageConfig{CPU: "2"}}}
    67  	nodes := []model.NodeInfo{s.smallPeer, s.medPeer, s.largePeer}
    68  	ranks, err := s.MaxUsageNodeRanker.RankNodes(context.Background(), job, nodes)
    69  	s.NoError(err)
    70  	s.Equal(len(nodes), len(ranks))
    71  	assertEquals(s.T(), ranks, "small", -1)
    72  	assertEquals(s.T(), ranks, "med", 10)
    73  	assertEquals(s.T(), ranks, "large", 10)
    74  }
    75  
    76  func (s *MaxUsageNodeRankerSuite) TestRankNodes_LargeJob() {
    77  	job := model.Job{Spec: model.Spec{Resources: model.ResourceUsageConfig{CPU: "3"}}}
    78  	nodes := []model.NodeInfo{s.smallPeer, s.medPeer, s.largePeer}
    79  	ranks, err := s.MaxUsageNodeRanker.RankNodes(context.Background(), job, nodes)
    80  	s.NoError(err)
    81  	s.Equal(len(nodes), len(ranks))
    82  	assertEquals(s.T(), ranks, "small", -1)
    83  	assertEquals(s.T(), ranks, "med", -1)
    84  	assertEquals(s.T(), ranks, "large", 10)
    85  }
    86  
    87  func (s *MaxUsageNodeRankerSuite) TestRankNodes_VeryLargeJob() {
    88  	job := model.Job{Spec: model.Spec{Resources: model.ResourceUsageConfig{CPU: "3.1"}}}
    89  	nodes := []model.NodeInfo{s.smallPeer, s.medPeer, s.largePeer}
    90  	ranks, err := s.MaxUsageNodeRanker.RankNodes(context.Background(), job, nodes)
    91  	s.NoError(err)
    92  	s.Equal(len(nodes), len(ranks))
    93  	assertEquals(s.T(), ranks, "small", -1)
    94  	assertEquals(s.T(), ranks, "med", -1)
    95  	assertEquals(s.T(), ranks, "large", -1)
    96  }
    97  
    98  func (s *MaxUsageNodeRankerSuite) TestRankNodesUnknownJob() {
    99  	job := model.Job{}
   100  	nodes := []model.NodeInfo{s.smallPeer, s.medPeer, s.largePeer}
   101  	ranks, err := s.MaxUsageNodeRanker.RankNodes(context.Background(), job, nodes)
   102  	s.NoError(err)
   103  	s.Equal(len(nodes), len(ranks))
   104  	assertEquals(s.T(), ranks, "small", 0)
   105  	assertEquals(s.T(), ranks, "med", 0)
   106  	assertEquals(s.T(), ranks, "large", 0)
   107  }