This is an automated email from the ASF dual-hosted git repository.
pbacsko pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/yunikorn-core.git
The following commit(s) were added to refs/heads/master by this push:
new dd77c6db [YUNIKORN-2398] Refactor event system mock (#792)
dd77c6db is described below
commit dd77c6db6bb2efae50e57123b08159d9070b793e
Author: Wilfred Spiegelenburg <[email protected]>
AuthorDate: Fri Feb 9 17:41:47 2024 +0100
[YUNIKORN-2398] Refactor event system mock (#792)
Move the event system mock into its own package under the events
package.
Move the node iterator creation function for tests to the utilities
file of the scheduler objects tests
Closes: #792
Signed-off-by: Peter Bacsko <[email protected]>
---
pkg/events/mock/event_system.go | 67 +++++++++
pkg/scheduler/objects/allocation_ask_test.go | 11 +-
pkg/scheduler/objects/application_events_test.go | 155 ++++++++++-----------
pkg/scheduler/objects/application_test.go | 25 ++--
pkg/scheduler/objects/ask_events_test.go | 67 ++++-----
pkg/scheduler/objects/common_test.go | 87 ------------
pkg/scheduler/objects/node_events_test.go | 167 ++++++++++++-----------
pkg/scheduler/objects/node_test.go | 41 +++---
pkg/scheduler/objects/queue_events_test.go | 119 ++++++++--------
pkg/scheduler/objects/utilities_test.go | 16 +++
10 files changed, 379 insertions(+), 376 deletions(-)
diff --git a/pkg/events/mock/event_system.go b/pkg/events/mock/event_system.go
new file mode 100644
index 00000000..f21482b7
--- /dev/null
+++ b/pkg/events/mock/event_system.go
@@ -0,0 +1,67 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+package mock
+
+import (
+ "github.com/apache/yunikorn-core/pkg/events"
+ "github.com/apache/yunikorn-scheduler-interface/lib/go/si"
+)
+
+type EventSystem struct {
+ Events []*si.EventRecord
+ enabled bool
+}
+
+func (m *EventSystem) CreateEventStream(_ string, _ uint64)
*events.EventStream {
+ return nil
+}
+
+func (m *EventSystem) RemoveStream(_ *events.EventStream) {
+}
+
+func (m *EventSystem) AddEvent(event *si.EventRecord) {
+ m.Events = append(m.Events, event)
+}
+
+func (m *EventSystem) StartService() {}
+
+func (m *EventSystem) Stop() {}
+
+func (m *EventSystem) Reset() {
+ m.Events = make([]*si.EventRecord, 0)
+}
+
+func (m *EventSystem) GetEventsFromID(uint64, uint64) ([]*si.EventRecord,
uint64, uint64) {
+ return nil, 0, 0
+}
+
+func (m *EventSystem) IsEventTrackingEnabled() bool {
+ return m.enabled
+}
+
+func (m *EventSystem) GetEventStreams() []events.EventStreamData {
+ return nil
+}
+
+func NewEventSystem() *EventSystem {
+ return &EventSystem{Events: make([]*si.EventRecord, 0), enabled: true}
+}
+func NewEventSystemDisabled() *EventSystem {
+ return &EventSystem{Events: make([]*si.EventRecord, 0), enabled: false}
+}
diff --git a/pkg/scheduler/objects/allocation_ask_test.go
b/pkg/scheduler/objects/allocation_ask_test.go
index e10e925e..59bc47da 100644
--- a/pkg/scheduler/objects/allocation_ask_test.go
+++ b/pkg/scheduler/objects/allocation_ask_test.go
@@ -26,6 +26,7 @@ import (
"gotest.tools/v3/assert"
"github.com/apache/yunikorn-core/pkg/common/resources"
+ "github.com/apache/yunikorn-core/pkg/events/mock"
"github.com/apache/yunikorn-scheduler-interface/lib/go/common"
"github.com/apache/yunikorn-scheduler-interface/lib/go/si"
)
@@ -238,16 +239,16 @@ func TestSendPredicateFailed(t *testing.T) {
ResourceAsk: res.ToProto(),
}
ask := NewAllocationAskFromSI(siAsk)
- eventSystem := newEventSystemMockDisabled()
+ eventSystem := mock.NewEventSystemDisabled()
ask.askEvents = newAskEvents(ask, eventSystem)
ask.SendPredicateFailedEvent("failed")
- assert.Equal(t, 0, len(eventSystem.events))
+ assert.Equal(t, 0, len(eventSystem.Events))
- eventSystem = newEventSystemMock()
+ eventSystem = mock.NewEventSystem()
ask.askEvents = newAskEvents(ask, eventSystem)
ask.SendPredicateFailedEvent("failure")
- assert.Equal(t, 1, len(eventSystem.events))
- event := eventSystem.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event := eventSystem.Events[0]
assert.Equal(t, "Predicate failed for request 'ask-1' with message:
'failure'", event.Message)
}
diff --git a/pkg/scheduler/objects/application_events_test.go
b/pkg/scheduler/objects/application_events_test.go
index c4d6d0e4..7e29f6ae 100644
--- a/pkg/scheduler/objects/application_events_test.go
+++ b/pkg/scheduler/objects/application_events_test.go
@@ -23,6 +23,7 @@ import (
"testing"
"github.com/apache/yunikorn-core/pkg/common"
+ "github.com/apache/yunikorn-core/pkg/events/mock"
"github.com/apache/yunikorn-scheduler-interface/lib/go/si"
)
@@ -51,20 +52,20 @@ func TestSendPlaceholderLargerEvent(t *testing.T) {
app := &Application{
queuePath: "root.test",
}
- mock := newEventSystemMockDisabled()
- appEvents := newApplicationEvents(app, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ appEvents := newApplicationEvents(app, eventSystem)
appEvents.sendPlaceholderLargerEvent(&Allocation{}, &AllocationAsk{})
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- appEvents = newApplicationEvents(app, mock)
+ eventSystem = mock.NewEventSystem()
+ appEvents = newApplicationEvents(app, eventSystem)
appEvents.sendPlaceholderLargerEvent(&Allocation{
allocationKey: aKey,
}, &AllocationAsk{
applicationID: appID0,
allocationKey: aKey,
})
- assert.Equal(t, 1, len(mock.events), "event was not generated")
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
}
func TestSendNewAllocationEvent(t *testing.T) {
@@ -72,26 +73,26 @@ func TestSendNewAllocationEvent(t *testing.T) {
ApplicationID: appID0,
queuePath: "root.test",
}
- mock := newEventSystemMockDisabled()
- appEvents := newApplicationEvents(app, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ appEvents := newApplicationEvents(app, eventSystem)
appEvents.sendNewAllocationEvent(&Allocation{})
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- appEvents = newApplicationEvents(app, mock)
+ eventSystem = mock.NewEventSystem()
+ appEvents = newApplicationEvents(app, eventSystem)
assert.Assert(t, appEvents.eventSystem != nil, "event system should not
be nil")
appEvents.sendNewAllocationEvent(&Allocation{
applicationID: appID0,
allocationKey: aKey,
allocationID: aAllocationID,
})
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- assert.Equal(t, si.EventRecord_APP, mock.events[0].Type, "event type is
not expected")
- assert.Equal(t, si.EventRecord_ADD, mock.events[0].EventChangeType,
"event change type is not expected")
- assert.Equal(t, si.EventRecord_APP_ALLOC,
mock.events[0].EventChangeDetail, "event change detail is not expected")
- assert.Equal(t, appID0, mock.events[0].ObjectID, "event object id is
not expected")
- assert.Equal(t, aAllocationID, mock.events[0].ReferenceID, "event
reference id is not expected")
- assert.Equal(t, common.Empty, mock.events[0].Message, "message is not
expected")
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ assert.Equal(t, si.EventRecord_APP, eventSystem.Events[0].Type, "event
type is not expected")
+ assert.Equal(t, si.EventRecord_ADD,
eventSystem.Events[0].EventChangeType, "event change type is not expected")
+ assert.Equal(t, si.EventRecord_APP_ALLOC,
eventSystem.Events[0].EventChangeDetail, "event change detail is not expected")
+ assert.Equal(t, appID0, eventSystem.Events[0].ObjectID, "event object
id is not expected")
+ assert.Equal(t, aAllocationID, eventSystem.Events[0].ReferenceID,
"event reference id is not expected")
+ assert.Equal(t, common.Empty, eventSystem.Events[0].Message, "message
is not expected")
}
func TestSendNewAskEvent(t *testing.T) {
@@ -99,25 +100,25 @@ func TestSendNewAskEvent(t *testing.T) {
ApplicationID: appID0,
queuePath: "root.test",
}
- mock := newEventSystemMockDisabled()
- appEvents := newApplicationEvents(app, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ appEvents := newApplicationEvents(app, eventSystem)
appEvents.sendNewAskEvent(&AllocationAsk{})
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- appEvents = newApplicationEvents(app, mock)
+ eventSystem = mock.NewEventSystem()
+ appEvents = newApplicationEvents(app, eventSystem)
assert.Assert(t, appEvents.eventSystem != nil, "event system should not
be nil")
appEvents.sendNewAskEvent(&AllocationAsk{
applicationID: appID0,
allocationKey: aKey,
})
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- assert.Equal(t, si.EventRecord_APP, mock.events[0].Type, "event type is
not expected")
- assert.Equal(t, si.EventRecord_ADD, mock.events[0].EventChangeType,
"event change type is not expected")
- assert.Equal(t, si.EventRecord_APP_REQUEST,
mock.events[0].EventChangeDetail, "event change detail is not expected")
- assert.Equal(t, appID0, mock.events[0].ObjectID, "event object id is
not expected")
- assert.Equal(t, aKey, mock.events[0].ReferenceID, "event reference id
is not expected")
- assert.Equal(t, common.Empty, mock.events[0].Message, "message is not
expected")
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ assert.Equal(t, si.EventRecord_APP, eventSystem.Events[0].Type, "event
type is not expected")
+ assert.Equal(t, si.EventRecord_ADD,
eventSystem.Events[0].EventChangeType, "event change type is not expected")
+ assert.Equal(t, si.EventRecord_APP_REQUEST,
eventSystem.Events[0].EventChangeDetail, "event change detail is not expected")
+ assert.Equal(t, appID0, eventSystem.Events[0].ObjectID, "event object
id is not expected")
+ assert.Equal(t, aKey, eventSystem.Events[0].ReferenceID, "event
reference id is not expected")
+ assert.Equal(t, common.Empty, eventSystem.Events[0].Message, "message
is not expected")
}
func TestSendRemoveAllocationEvent(t *testing.T) {
@@ -125,14 +126,14 @@ func TestSendRemoveAllocationEvent(t *testing.T) {
ApplicationID: appID0,
queuePath: "root.test",
}
- mock := newEventSystemMockDisabled()
- appEvents := newApplicationEvents(app, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ appEvents := newApplicationEvents(app, eventSystem)
appEvents.sendRemoveAllocationEvent(&Allocation{},
si.TerminationType_STOPPED_BY_RM)
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
testCases := []struct {
name string
- eventSystemMock *EventSystemMock
+ eventSystemMock *mock.EventSystem
terminationType si.TerminationType
allocation *Allocation
expectedEventCnt int
@@ -144,7 +145,7 @@ func TestSendRemoveAllocationEvent(t *testing.T) {
}{
{
name: "remove allocation cause of node
removal",
- eventSystemMock: newEventSystemMock(),
+ eventSystemMock: mock.NewEventSystem(),
terminationType:
si.TerminationType_UNKNOWN_TERMINATION_TYPE,
allocation: &Allocation{applicationID:
appID0, allocationKey: aKey, allocationID: aAllocationID},
expectedEventCnt: 1,
@@ -156,7 +157,7 @@ func TestSendRemoveAllocationEvent(t *testing.T) {
},
{
name: "remove allocation cause of
resource manager cancel",
- eventSystemMock: newEventSystemMock(),
+ eventSystemMock: mock.NewEventSystem(),
terminationType: si.TerminationType_STOPPED_BY_RM,
allocation: &Allocation{applicationID:
appID0, allocationKey: aKey, allocationID: aAllocationID},
expectedEventCnt: 1,
@@ -168,7 +169,7 @@ func TestSendRemoveAllocationEvent(t *testing.T) {
},
{
name: "remove allocation cause of
timeout",
- eventSystemMock: newEventSystemMock(),
+ eventSystemMock: mock.NewEventSystem(),
terminationType: si.TerminationType_TIMEOUT,
allocation: &Allocation{applicationID:
appID0, allocationKey: aKey, allocationID: aAllocationID},
expectedEventCnt: 1,
@@ -180,7 +181,7 @@ func TestSendRemoveAllocationEvent(t *testing.T) {
},
{
name: "remove allocation cause of
preemption",
- eventSystemMock: newEventSystemMock(),
+ eventSystemMock: mock.NewEventSystem(),
terminationType:
si.TerminationType_PREEMPTED_BY_SCHEDULER,
allocation: &Allocation{applicationID:
appID0, allocationKey: aKey, allocationID: aAllocationID},
expectedEventCnt: 1,
@@ -192,7 +193,7 @@ func TestSendRemoveAllocationEvent(t *testing.T) {
},
{
name: "remove allocation cause of
replacement",
- eventSystemMock: newEventSystemMock(),
+ eventSystemMock: mock.NewEventSystem(),
terminationType:
si.TerminationType_PLACEHOLDER_REPLACED,
allocation: &Allocation{applicationID:
appID0, allocationKey: aKey, allocationID: aAllocationID},
expectedEventCnt: 1,
@@ -213,13 +214,13 @@ func TestSendRemoveAllocationEvent(t *testing.T) {
appEvents := newApplicationEvents(app,
testCase.eventSystemMock)
assert.Assert(t, appEvents.eventSystem != nil,
"event system should not be nil")
appEvents.sendRemoveAllocationEvent(testCase.allocation,
testCase.terminationType)
- assert.Equal(t, testCase.expectedEventCnt,
len(testCase.eventSystemMock.events), "event was not generated")
- assert.Equal(t, testCase.expectedType,
testCase.eventSystemMock.events[0].Type, "event type is not expected")
- assert.Equal(t, testCase.expectedChangeType,
testCase.eventSystemMock.events[0].EventChangeType, "event change type is not
expected")
- assert.Equal(t, testCase.expectedChangeDetail,
testCase.eventSystemMock.events[0].EventChangeDetail, "event change detail is
not expected")
- assert.Equal(t, testCase.expectedObjectID,
testCase.eventSystemMock.events[0].ObjectID, "event object id is not expected")
- assert.Equal(t, testCase.expectedReferenceID,
testCase.eventSystemMock.events[0].ReferenceID, "event reference id is not
expected")
- assert.Equal(t, common.Empty,
testCase.eventSystemMock.events[0].Message, "message is not expected")
+ assert.Equal(t, testCase.expectedEventCnt,
len(testCase.eventSystemMock.Events), "event was not generated")
+ assert.Equal(t, testCase.expectedType,
testCase.eventSystemMock.Events[0].Type, "event type is not expected")
+ assert.Equal(t, testCase.expectedChangeType,
testCase.eventSystemMock.Events[0].EventChangeType, "event change type is not
expected")
+ assert.Equal(t, testCase.expectedChangeDetail,
testCase.eventSystemMock.Events[0].EventChangeDetail, "event change detail is
not expected")
+ assert.Equal(t, testCase.expectedObjectID,
testCase.eventSystemMock.Events[0].ObjectID, "event object id is not expected")
+ assert.Equal(t, testCase.expectedReferenceID,
testCase.eventSystemMock.Events[0].ReferenceID, "event reference id is not
expected")
+ assert.Equal(t, common.Empty,
testCase.eventSystemMock.Events[0].Message, "message is not expected")
}
})
}
@@ -230,18 +231,18 @@ func TestSendRemoveAskEvent(t *testing.T) {
ApplicationID: appID0,
queuePath: "root.test",
}
- mock := newEventSystemMockDisabled()
- appEvents := newApplicationEvents(app, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ appEvents := newApplicationEvents(app, eventSystem)
appEvents.sendRemoveAskEvent(&AllocationAsk{},
si.EventRecord_REQUEST_CANCEL)
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
ask := &AllocationAsk{
applicationID: appID0,
allocationKey: aKey}
- mock = newEventSystemMock()
- appEvents = newApplicationEvents(app, mock)
+ eventSystem = mock.NewEventSystem()
+ appEvents = newApplicationEvents(app, eventSystem)
appEvents.sendRemoveAskEvent(ask, si.EventRecord_REQUEST_CANCEL)
- event := mock.events[0]
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_APP, event.Type)
assert.Equal(t, si.EventRecord_REMOVE, event.EventChangeType)
assert.Equal(t, si.EventRecord_REQUEST_CANCEL, event.EventChangeDetail)
@@ -249,9 +250,9 @@ func TestSendRemoveAskEvent(t *testing.T) {
assert.Equal(t, "alloc-1", event.ReferenceID)
assert.Equal(t, "", event.Message)
- mock.Reset()
+ eventSystem.Reset()
appEvents.sendRemoveAskEvent(ask, si.EventRecord_REQUEST_TIMEOUT)
- event = mock.events[0]
+ event = eventSystem.Events[0]
assert.Equal(t, si.EventRecord_APP, event.Type)
assert.Equal(t, si.EventRecord_REMOVE, event.EventChangeType)
assert.Equal(t, si.EventRecord_REQUEST_TIMEOUT, event.EventChangeDetail)
@@ -265,15 +266,15 @@ func TestSendNewApplicationEvent(t *testing.T) {
ApplicationID: appID0,
queuePath: "root.test",
}
- mock := newEventSystemMockDisabled()
- appEvents := newApplicationEvents(app, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ appEvents := newApplicationEvents(app, eventSystem)
appEvents.sendNewApplicationEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mockEvents := newEventSystemMock()
+ mockEvents := mock.NewEventSystem()
appEvents = newApplicationEvents(app, mockEvents)
appEvents.sendNewApplicationEvent()
- event := mockEvents.events[0]
+ event := mockEvents.Events[0]
assert.Equal(t, si.EventRecord_APP, event.Type)
assert.Equal(t, si.EventRecord_ADD, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
@@ -287,15 +288,15 @@ func TestSendRemoveApplicationEvent(t *testing.T) {
ApplicationID: appID0,
queuePath: "root.test",
}
- mock := newEventSystemMockDisabled()
- appEvents := newApplicationEvents(app, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ appEvents := newApplicationEvents(app, eventSystem)
appEvents.sendRemoveApplicationEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- appEvents = newApplicationEvents(app, mock)
+ eventSystem = mock.NewEventSystem()
+ appEvents = newApplicationEvents(app, eventSystem)
appEvents.sendRemoveApplicationEvent()
- event := mock.events[0]
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_APP, event.Type)
assert.Equal(t, si.EventRecord_REMOVE, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
@@ -310,15 +311,15 @@ func TestSendStateChangeEvent(t *testing.T) {
queuePath: "root.test",
sendStateChangeEvents: true,
}
- mock := newEventSystemMockDisabled()
- appEvents := newApplicationEvents(app, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ appEvents := newApplicationEvents(app, eventSystem)
appEvents.sendStateChangeEvent(si.EventRecord_APP_RUNNING, "")
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- appEvents = newApplicationEvents(app, mock)
+ eventSystem = mock.NewEventSystem()
+ appEvents = newApplicationEvents(app, eventSystem)
appEvents.sendStateChangeEvent(si.EventRecord_APP_RUNNING, "The
application is running")
- event := mock.events[0]
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_APP, event.Type)
assert.Equal(t, si.EventRecord_SET, event.EventChangeType)
assert.Equal(t, si.EventRecord_APP_RUNNING, event.EventChangeDetail)
@@ -326,15 +327,15 @@ func TestSendStateChangeEvent(t *testing.T) {
assert.Equal(t, "", event.ReferenceID)
assert.Equal(t, "The application is running", event.Message)
- mock = newEventSystemMockDisabled()
- appEvents = newApplicationEvents(app, mock)
+ eventSystem = mock.NewEventSystemDisabled()
+ appEvents = newApplicationEvents(app, eventSystem)
appEvents.sendStateChangeEvent(si.EventRecord_APP_RUNNING,
"ResourceReservationTimeout")
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- appEvents = newApplicationEvents(app, mock)
+ eventSystem = mock.NewEventSystem()
+ appEvents = newApplicationEvents(app, eventSystem)
appEvents.sendStateChangeEvent(si.EventRecord_APP_REJECT, "Failed to
add application to partition (placement rejected)")
- event = mock.events[0]
+ event = eventSystem.Events[0]
assert.Equal(t, si.EventRecord_APP, event.Type)
assert.Equal(t, si.EventRecord_SET, event.EventChangeType)
assert.Equal(t, si.EventRecord_APP_REJECT, event.EventChangeDetail)
diff --git a/pkg/scheduler/objects/application_test.go
b/pkg/scheduler/objects/application_test.go
index 742f3ac8..3136d06a 100644
--- a/pkg/scheduler/objects/application_test.go
+++ b/pkg/scheduler/objects/application_test.go
@@ -31,6 +31,7 @@ import (
"github.com/apache/yunikorn-core/pkg/common/resources"
"github.com/apache/yunikorn-core/pkg/common/security"
"github.com/apache/yunikorn-core/pkg/events"
+ "github.com/apache/yunikorn-core/pkg/events/mock"
"github.com/apache/yunikorn-core/pkg/handler"
"github.com/apache/yunikorn-core/pkg/rmproxy"
"github.com/apache/yunikorn-core/pkg/rmproxy/rmevent"
@@ -2265,7 +2266,7 @@ func TestRequestDoesNotFitQueueEvents(t *testing.T) {
assert.NilError(t, err)
ask := newAllocationAsk("alloc-0", "app-1", res)
app := newApplication(appID1, "default", "root.default")
- eventSystem := newEventSystemMock()
+ eventSystem := mock.NewEventSystem()
ask.askEvents = newAskEvents(ask, eventSystem)
app.disableStateChangeEvents()
app.resetAppEvents()
@@ -2279,8 +2280,8 @@ func TestRequestDoesNotFitQueueEvents(t *testing.T) {
// try to allocate
app.tryAllocate(headroom, true, time.Second, &attempts,
nilNodeIterator, nilNodeIterator, nilGetNode)
- assert.Equal(t, 1, len(eventSystem.events))
- event := eventSystem.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_REQUEST, event.Type)
assert.Equal(t, si.EventRecord_NONE, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
@@ -2290,15 +2291,15 @@ func TestRequestDoesNotFitQueueEvents(t *testing.T) {
// second attempt - no new event
app.tryAllocate(headroom, true, time.Second, &attempts,
nilNodeIterator, nilNodeIterator, nilGetNode)
- assert.Equal(t, 1, len(eventSystem.events))
+ assert.Equal(t, 1, len(eventSystem.Events))
// third attempt with enough headroom - new event
eventSystem.Reset()
headroom, err =
resources.NewResourceFromConf(map[string]string{"memory": "1000", "vcores":
"1000"})
assert.NilError(t, err)
app.tryAllocate(headroom, true, time.Second, &attempts,
nilNodeIterator, nilNodeIterator, nilGetNode)
- assert.Equal(t, 1, len(eventSystem.events))
- event = eventSystem.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event = eventSystem.Events[0]
assert.Equal(t, si.EventRecord_REQUEST, event.Type)
assert.Equal(t, si.EventRecord_NONE, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
@@ -2336,7 +2337,7 @@ func TestRequestDoesNotFitUserQuotaQueueEvents(t
*testing.T) {
assert.NilError(t, err)
ask := newAllocationAsk("alloc-0", "app-1", res)
app := newApplication(appID1, "default", "root")
- eventSystem := newEventSystemMock()
+ eventSystem := mock.NewEventSystem()
ask.askEvents = newAskEvents(ask, eventSystem)
app.disableStateChangeEvents()
app.resetAppEvents()
@@ -2350,8 +2351,8 @@ func TestRequestDoesNotFitUserQuotaQueueEvents(t
*testing.T) {
// try to allocate
app.tryAllocate(headroom, true, time.Second, &attempts,
nilNodeIterator, nilNodeIterator, nilGetNode)
- assert.Equal(t, 1, len(eventSystem.events))
- event := eventSystem.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_REQUEST, event.Type)
assert.Equal(t, si.EventRecord_NONE, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
@@ -2361,7 +2362,7 @@ func TestRequestDoesNotFitUserQuotaQueueEvents(t
*testing.T) {
// second attempt - no new event
app.tryAllocate(headroom, true, time.Second, &attempts,
nilNodeIterator, nilNodeIterator, nilGetNode)
- assert.Equal(t, 1, len(eventSystem.events))
+ assert.Equal(t, 1, len(eventSystem.Events))
// third attempt with enough headroom - new event
eventSystem.Reset()
@@ -2369,8 +2370,8 @@ func TestRequestDoesNotFitUserQuotaQueueEvents(t
*testing.T) {
err = ugm.GetUserManager().UpdateConfig(conf, "root")
assert.NilError(t, err)
app.tryAllocate(headroom, true, time.Second, &attempts,
nilNodeIterator, nilNodeIterator, nilGetNode)
- assert.Equal(t, 1, len(eventSystem.events))
- event = eventSystem.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event = eventSystem.Events[0]
assert.Equal(t, si.EventRecord_REQUEST, event.Type)
assert.Equal(t, si.EventRecord_NONE, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
diff --git a/pkg/scheduler/objects/ask_events_test.go
b/pkg/scheduler/objects/ask_events_test.go
index cffe4693..75630247 100644
--- a/pkg/scheduler/objects/ask_events_test.go
+++ b/pkg/scheduler/objects/ask_events_test.go
@@ -26,6 +26,7 @@ import (
"gotest.tools/v3/assert"
"github.com/apache/yunikorn-core/pkg/common/resources"
+ "github.com/apache/yunikorn-core/pkg/events/mock"
"github.com/apache/yunikorn-scheduler-interface/lib/go/si"
)
@@ -40,22 +41,22 @@ func TestRequestDoesNotFitInQueueEvent(t *testing.T) {
applicationID: "app-0",
allocatedResource: requestResource,
}
- eventSystem := newEventSystemMockDisabled()
+ eventSystem := mock.NewEventSystemDisabled()
events := newAskEvents(ask, eventSystem)
- events.sendRequestExceedsQueueHeadroom(getTestResource(), "root.test")
- assert.Equal(t, 0, len(eventSystem.events))
+
events.sendRequestExceedsQueueHeadroom(resources.NewResourceFromMap(map[string]resources.Quantity{"first":
1}), "root.test")
+ assert.Equal(t, 0, len(eventSystem.Events))
- eventSystem = newEventSystemMock()
+ eventSystem = mock.NewEventSystem()
events = newAskEvents(ask, eventSystem)
- events.sendRequestExceedsQueueHeadroom(getTestResource(), "root.test")
- assert.Equal(t, 1, len(eventSystem.events))
- event := eventSystem.events[0]
+
events.sendRequestExceedsQueueHeadroom(resources.NewResourceFromMap(map[string]resources.Quantity{"first":
1}), "root.test")
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event := eventSystem.Events[0]
assert.Equal(t, "alloc-0", event.ObjectID)
assert.Equal(t, "app-0", event.ReferenceID)
assert.Equal(t, si.EventRecord_REQUEST, event.Type)
assert.Equal(t, si.EventRecord_NONE, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
- assert.Equal(t, "Request 'alloc-0' does not fit in queue 'root.test'
(requested map[cpu:100 memory:100], available map[cpu:1])", event.Message)
+ assert.Equal(t, "Request 'alloc-0' does not fit in queue 'root.test'
(requested map[cpu:100 memory:100], available map[first:1])", event.Message)
}
func TestRequestFitsInQueueEvent(t *testing.T) {
@@ -64,16 +65,16 @@ func TestRequestFitsInQueueEvent(t *testing.T) {
applicationID: "app-0",
allocatedResource: requestResource,
}
- eventSystem := newEventSystemMockDisabled()
+ eventSystem := mock.NewEventSystemDisabled()
events := newAskEvents(ask, eventSystem)
events.sendRequestFitsInQueue("root.test")
- assert.Equal(t, 0, len(eventSystem.events))
+ assert.Equal(t, 0, len(eventSystem.Events))
- eventSystem = newEventSystemMock()
+ eventSystem = mock.NewEventSystem()
events = newAskEvents(ask, eventSystem)
events.sendRequestFitsInQueue("root.test")
- assert.Equal(t, 1, len(eventSystem.events))
- event := eventSystem.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event := eventSystem.Events[0]
assert.Equal(t, "alloc-0", event.ObjectID)
assert.Equal(t, "app-0", event.ReferenceID)
assert.Equal(t, si.EventRecord_REQUEST, event.Type)
@@ -88,22 +89,22 @@ func TestRequestExceedsUserQuotaEvent(t *testing.T) {
applicationID: "app-0",
allocatedResource: requestResource,
}
- eventSystem := newEventSystemMockDisabled()
+ eventSystem := mock.NewEventSystemDisabled()
events := newAskEvents(ask, eventSystem)
- events.sendRequestExceedsUserQuota(getTestResource())
- assert.Equal(t, 0, len(eventSystem.events))
+
events.sendRequestExceedsUserQuota(resources.NewResourceFromMap(map[string]resources.Quantity{"first":
1}))
+ assert.Equal(t, 0, len(eventSystem.Events))
- eventSystem = newEventSystemMock()
+ eventSystem = mock.NewEventSystem()
events = newAskEvents(ask, eventSystem)
- events.sendRequestExceedsUserQuota(getTestResource())
- assert.Equal(t, 1, len(eventSystem.events))
- event := eventSystem.events[0]
+
events.sendRequestExceedsUserQuota(resources.NewResourceFromMap(map[string]resources.Quantity{"first":
1}))
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event := eventSystem.Events[0]
assert.Equal(t, "alloc-0", event.ObjectID)
assert.Equal(t, "app-0", event.ReferenceID)
assert.Equal(t, si.EventRecord_REQUEST, event.Type)
assert.Equal(t, si.EventRecord_NONE, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
- assert.Equal(t, "Request 'alloc-0' exceeds the available user quota
(requested map[cpu:100 memory:100], available map[cpu:1])", event.Message)
+ assert.Equal(t, "Request 'alloc-0' exceeds the available user quota
(requested map[cpu:100 memory:100], available map[first:1])", event.Message)
}
func TestRequestFitsInUserQuotaEvent(t *testing.T) {
@@ -112,16 +113,16 @@ func TestRequestFitsInUserQuotaEvent(t *testing.T) {
applicationID: "app-0",
allocatedResource: requestResource,
}
- eventSystem := newEventSystemMockDisabled()
+ eventSystem := mock.NewEventSystemDisabled()
events := newAskEvents(ask, eventSystem)
events.sendRequestFitsInUserQuota()
- assert.Equal(t, 0, len(eventSystem.events))
+ assert.Equal(t, 0, len(eventSystem.Events))
- eventSystem = newEventSystemMock()
+ eventSystem = mock.NewEventSystem()
events = newAskEvents(ask, eventSystem)
events.sendRequestFitsInUserQuota()
- assert.Equal(t, 1, len(eventSystem.events))
- event := eventSystem.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event := eventSystem.Events[0]
assert.Equal(t, "alloc-0", event.ObjectID)
assert.Equal(t, "app-0", event.ReferenceID)
assert.Equal(t, si.EventRecord_REQUEST, event.Type)
@@ -136,26 +137,26 @@ func TestPredicateFailedEvents(t *testing.T) {
applicationID: "app-0",
allocatedResource: requestResource,
}
- eventSystem := newEventSystemMockDisabled()
+ eventSystem := mock.NewEventSystemDisabled()
events := newAskEvents(ask, eventSystem)
events.sendPredicateFailed("failed")
- assert.Equal(t, 0, len(eventSystem.events))
+ assert.Equal(t, 0, len(eventSystem.Events))
- eventSystem = newEventSystemMock()
+ eventSystem = mock.NewEventSystem()
events = newAskEventsWithRate(ask, eventSystem, 50*time.Millisecond, 1)
// only the first event is expected to be emitted due to rate limiting
for i := 0; i < 200; i++ {
events.sendPredicateFailed("failure-" +
strconv.FormatUint(uint64(i), 10))
}
- assert.Equal(t, 1, len(eventSystem.events))
- event := eventSystem.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event := eventSystem.Events[0]
assert.Equal(t, "Predicate failed for request 'alloc-0' with message:
'failure-0'", event.Message)
eventSystem.Reset()
// wait a bit, a new event is expected
time.Sleep(100 * time.Millisecond)
events.sendPredicateFailed("failed")
- assert.Equal(t, 1, len(eventSystem.events))
- event = eventSystem.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events))
+ event = eventSystem.Events[0]
assert.Equal(t, "Predicate failed for request 'alloc-0' with message:
'failed'", event.Message)
}
diff --git a/pkg/scheduler/objects/common_test.go
b/pkg/scheduler/objects/common_test.go
deleted file mode 100644
index 52dd536f..00000000
--- a/pkg/scheduler/objects/common_test.go
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you under the Apache License, Version 2.0 (the
- "License"); you may not use this file except in compliance
- with the License. You may obtain a copy of the License at
- http://www.apache.org/licenses/LICENSE-2.0
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-*/
-
-package objects
-
-import (
- "github.com/google/btree"
-
- "github.com/apache/yunikorn-core/pkg/common/resources"
- "github.com/apache/yunikorn-core/pkg/events"
- "github.com/apache/yunikorn-scheduler-interface/lib/go/si"
-)
-
-type EventSystemMock struct {
- events []*si.EventRecord
- enabled bool
-}
-
-func (m *EventSystemMock) CreateEventStream(_ string, _ uint64)
*events.EventStream {
- return nil
-}
-
-func (m *EventSystemMock) RemoveStream(_ *events.EventStream) {
-}
-
-func (m *EventSystemMock) AddEvent(event *si.EventRecord) {
- m.events = append(m.events, event)
-}
-
-func (m *EventSystemMock) StartService() {}
-
-func (m *EventSystemMock) Stop() {}
-
-func (m *EventSystemMock) Reset() {
- m.events = make([]*si.EventRecord, 0)
-}
-
-func (m *EventSystemMock) GetEventsFromID(uint64, uint64) ([]*si.EventRecord,
uint64, uint64) {
- return nil, 0, 0
-}
-
-func (m *EventSystemMock) IsEventTrackingEnabled() bool {
- return m.enabled
-}
-
-func (m *EventSystemMock) GetEventStreams() []events.EventStreamData {
- return nil
-}
-
-func newEventSystemMock() *EventSystemMock {
- return &EventSystemMock{events: make([]*si.EventRecord, 0), enabled:
true}
-}
-func newEventSystemMockDisabled() *EventSystemMock {
- return &EventSystemMock{events: make([]*si.EventRecord, 0), enabled:
false}
-}
-
-func getTestResource() *resources.Resource {
- return
resources.NewResourceFromMap(map[string]resources.Quantity{"cpu": 1})
-}
-
-func getNodeIteratorFn(nodes ...*Node) func() NodeIterator {
- tree := btree.New(7)
- for _, node := range nodes {
- tree.ReplaceOrInsert(nodeRef{
- node, 1,
- })
- }
-
- return func() NodeIterator {
- return NewTreeIterator(acceptAll, func() *btree.BTree {
- return tree
- })
- }
-}
diff --git a/pkg/scheduler/objects/node_events_test.go
b/pkg/scheduler/objects/node_events_test.go
index 07d54779..aadd8375 100644
--- a/pkg/scheduler/objects/node_events_test.go
+++ b/pkg/scheduler/objects/node_events_test.go
@@ -25,6 +25,7 @@ import (
"github.com/apache/yunikorn-core/pkg/common"
"github.com/apache/yunikorn-core/pkg/common/resources"
+ "github.com/apache/yunikorn-core/pkg/events/mock"
"github.com/apache/yunikorn-scheduler-interface/lib/go/si"
)
@@ -32,16 +33,16 @@ func TestSendNodeAddedEvent(t *testing.T) {
node := &Node{
NodeID: nodeID1,
}
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendNodeAddedEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendNodeAddedEvent()
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
assert.Equal(t, "Node added to the scheduler", event.Message)
@@ -54,16 +55,16 @@ func TestSendNodeRemovedEvent(t *testing.T) {
node := &Node{
NodeID: nodeID1,
}
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendNodeRemovedEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendNodeRemovedEvent()
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
assert.Equal(t, "Node removed from the scheduler", event.Message)
@@ -76,18 +77,18 @@ func TestSendAllocationAddedEvent(t *testing.T) {
node := &Node{
NodeID: nodeID1,
}
- resource := getTestResource()
+ resource :=
resources.NewResourceFromMap(map[string]resources.Quantity{"first": 1})
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendAllocationAddedEvent("alloc-0", resource)
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendAllocationAddedEvent("alloc-0", resource)
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, "alloc-0", event.ReferenceID)
assert.Equal(t, common.Empty, event.Message)
@@ -102,17 +103,17 @@ func TestSendAllocationRemovedEvent(t *testing.T) {
node := &Node{
NodeID: nodeID1,
}
- resource := getTestResource()
+ resource :=
resources.NewResourceFromMap(map[string]resources.Quantity{"first": 1})
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendAllocationRemovedEvent("alloc-0", resource)
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendAllocationRemovedEvent("alloc-0", resource)
- event := mock.events[0]
+ event := eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, "alloc-0", event.ReferenceID)
assert.Equal(t, common.Empty, event.Message)
@@ -127,41 +128,41 @@ func TestSendNodeReadyChangedEvent(t *testing.T) {
node := &Node{
NodeID: nodeID1,
}
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendNodeReadyChangedEvent(true)
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendNodeReadyChangedEvent(true)
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- assert.Equal(t, "ready: true", mock.events[0].Message)
- assert.Equal(t, nodeID1, mock.events[0].ObjectID)
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ assert.Equal(t, "ready: true", eventSystem.Events[0].Message)
+ assert.Equal(t, nodeID1, eventSystem.Events[0].ObjectID)
- mock.Reset()
+ eventSystem.Reset()
ne.sendNodeReadyChangedEvent(false)
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- assert.Equal(t, "ready: false", mock.events[0].Message)
- assert.Equal(t, nodeID1, mock.events[0].ObjectID)
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ assert.Equal(t, "ready: false", eventSystem.Events[0].Message)
+ assert.Equal(t, nodeID1, eventSystem.Events[0].ObjectID)
}
func TestSendOccupiedResourceChangedEvent(t *testing.T) {
- resource := getTestResource()
+ resource :=
resources.NewResourceFromMap(map[string]resources.Quantity{"first": 1})
node := &Node{
NodeID: nodeID1,
occupiedResource: resource,
}
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendNodeOccupiedResourceChangedEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendNodeOccupiedResourceChangedEvent()
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
assert.Equal(t, common.Empty, event.Message)
@@ -173,21 +174,21 @@ func TestSendOccupiedResourceChangedEvent(t *testing.T) {
}
func TestSendCapacityChangedEvent(t *testing.T) {
- resource := getTestResource()
+ resource :=
resources.NewResourceFromMap(map[string]resources.Quantity{"first": 1})
node := &Node{
NodeID: nodeID1,
totalResource: resource,
}
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendNodeCapacityChangedEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendNodeCapacityChangedEvent()
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
assert.Equal(t, common.Empty, event.Message)
@@ -203,16 +204,16 @@ func TestNodeSchedulableChangedEvent(t *testing.T) {
NodeID: nodeID1,
schedulable: true,
}
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendNodeSchedulableChangedEvent(false)
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendNodeSchedulableChangedEvent(false)
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
assert.Equal(t, "schedulable: false", event.Message)
@@ -220,10 +221,10 @@ func TestNodeSchedulableChangedEvent(t *testing.T) {
assert.Equal(t, si.EventRecord_NODE_SCHEDULABLE,
event.EventChangeDetail)
assert.Equal(t, 0, len(event.Resource.Resources))
- mock.Reset()
+ eventSystem.Reset()
ne.sendNodeSchedulableChangedEvent(true)
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event = mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event = eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
assert.Equal(t, "schedulable: true", event.Message)
@@ -233,21 +234,21 @@ func TestNodeSchedulableChangedEvent(t *testing.T) {
}
func TestNodeReservationEvent(t *testing.T) {
- resource := getTestResource()
+ resource :=
resources.NewResourceFromMap(map[string]resources.Quantity{"first": 1})
node := &Node{
NodeID: nodeID1,
schedulable: true,
}
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendReservedEvent(resource, "alloc-0")
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendReservedEvent(resource, "alloc-0")
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, "alloc-0", event.ReferenceID)
assert.Equal(t, common.Empty, event.Message)
@@ -259,21 +260,21 @@ func TestNodeReservationEvent(t *testing.T) {
}
func TestNodeUnreservationEvent(t *testing.T) {
- resource := getTestResource()
+ resource :=
resources.NewResourceFromMap(map[string]resources.Quantity{"first": 1})
node := &Node{
NodeID: nodeID1,
schedulable: true,
}
- mock := newEventSystemMockDisabled()
- ne := newNodeEvents(node, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ ne := newNodeEvents(node, eventSystem)
ne.sendUnreservedEvent(resource, "alloc-0")
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- ne = newNodeEvents(node, mock)
+ eventSystem = mock.NewEventSystem()
+ ne = newNodeEvents(node, eventSystem)
ne.sendUnreservedEvent(resource, "alloc-0")
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, nodeID1, event.ObjectID)
assert.Equal(t, "alloc-0", event.ReferenceID)
assert.Equal(t, common.Empty, event.Message)
diff --git a/pkg/scheduler/objects/node_test.go
b/pkg/scheduler/objects/node_test.go
index e5ce3e4a..f7f2dd67 100644
--- a/pkg/scheduler/objects/node_test.go
+++ b/pkg/scheduler/objects/node_test.go
@@ -25,6 +25,7 @@ import (
"gotest.tools/v3/assert"
"github.com/apache/yunikorn-core/pkg/common/resources"
+ evtMock "github.com/apache/yunikorn-core/pkg/events/mock"
"github.com/apache/yunikorn-core/pkg/mock"
"github.com/apache/yunikorn-core/pkg/plugins"
"github.com/apache/yunikorn-scheduler-interface/lib/go/common"
@@ -638,7 +639,7 @@ type testListener struct {
updateCount int
}
-func (tl *testListener) NodeUpdated(node *Node) {
+func (tl *testListener) NodeUpdated(_ *Node) {
tl.updateCount++
}
@@ -687,7 +688,7 @@ func TestReadyAttribute(t *testing.T) {
}
func TestNodeEvents(t *testing.T) {
- mockEvents := newEventSystemMock()
+ mockEvents := evtMock.NewEventSystem()
total :=
resources.NewResourceFromMap(map[string]resources.Quantity{"cpu": 100,
"memory": 100})
occupied :=
resources.NewResourceFromMap(map[string]resources.Quantity{"cpu": 10, "memory":
10})
proto := newProto(testNode, total, occupied, map[string]string{
@@ -697,22 +698,22 @@ func TestNodeEvents(t *testing.T) {
node.nodeEvents = newNodeEvents(node, mockEvents)
node.SendNodeAddedEvent()
- assert.Equal(t, 1, len(mockEvents.events))
- event := mockEvents.events[0]
+ assert.Equal(t, 1, len(mockEvents.Events))
+ event := mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_ADD, event.EventChangeType)
mockEvents.Reset()
node.SendNodeRemovedEvent()
- assert.Equal(t, 1, len(mockEvents.events))
- event = mockEvents.events[0]
+ assert.Equal(t, 1, len(mockEvents.Events))
+ event = mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_REMOVE, event.EventChangeType)
mockEvents.Reset()
node.SetReady(false)
- assert.Equal(t, 1, len(mockEvents.events))
- event = mockEvents.events[0]
+ assert.Equal(t, 1, len(mockEvents.Events))
+ event = mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_SET, event.EventChangeType)
assert.Equal(t, si.EventRecord_NODE_READY, event.EventChangeDetail)
@@ -723,22 +724,22 @@ func TestNodeEvents(t *testing.T) {
allocationKey: aKey,
allocationID: "allocationid-0",
})
- assert.Equal(t, 1, len(mockEvents.events))
- event = mockEvents.events[0]
+ assert.Equal(t, 1, len(mockEvents.Events))
+ event = mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_ADD, event.EventChangeType)
assert.Equal(t, si.EventRecord_NODE_ALLOC, event.EventChangeDetail)
mockEvents.Reset()
node.RemoveAllocation("allocationid-0")
- event = mockEvents.events[0]
+ event = mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_REMOVE, event.EventChangeType)
assert.Equal(t, si.EventRecord_NODE_ALLOC, event.EventChangeDetail)
mockEvents.Reset()
node.SetOccupiedResource(resources.NewResourceFromMap(map[string]resources.Quantity{"cpu":
20, "memory": 20}))
- event = mockEvents.events[0]
+ event = mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_SET, event.EventChangeType)
assert.Equal(t, si.EventRecord_NODE_OCCUPIED, event.EventChangeDetail)
@@ -747,7 +748,7 @@ func TestNodeEvents(t *testing.T) {
mockEvents.Reset()
node.SetCapacity(resources.NewResourceFromMap(map[string]resources.Quantity{"cpu":
90, "memory": 90}))
- event = mockEvents.events[0]
+ event = mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_SET, event.EventChangeType)
assert.Equal(t, si.EventRecord_NODE_CAPACITY, event.EventChangeDetail)
@@ -756,7 +757,7 @@ func TestNodeEvents(t *testing.T) {
mockEvents.Reset()
node.SetSchedulable(false)
- event = mockEvents.events[0]
+ event = mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_SET, event.EventChangeType)
assert.Equal(t, si.EventRecord_NODE_SCHEDULABLE,
event.EventChangeDetail)
@@ -767,7 +768,7 @@ func TestNodeEvents(t *testing.T) {
app := newApplication(appID1, "default", "root.unknown")
err := node.Reserve(app, ask)
assert.NilError(t, err, "could not reserve")
- event = mockEvents.events[0]
+ event = mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_ADD, event.EventChangeType)
assert.Equal(t, si.EventRecord_NODE_RESERVATION,
event.EventChangeDetail)
@@ -775,7 +776,7 @@ func TestNodeEvents(t *testing.T) {
mockEvents.Reset()
_, err = node.unReserve(app, ask)
assert.NilError(t, err, "could not unreserve")
- event = mockEvents.events[0]
+ event = mockEvents.Events[0]
assert.Equal(t, si.EventRecord_NODE, event.Type)
assert.Equal(t, si.EventRecord_REMOVE, event.EventChangeType)
assert.Equal(t, si.EventRecord_NODE_RESERVATION,
event.EventChangeDetail)
@@ -823,14 +824,14 @@ func TestPreconditions(t *testing.T) {
})
res :=
resources.NewResourceFromMap(map[string]resources.Quantity{"first": 1})
ask := newAllocationAsk("test", "app001", res)
- eventSystem := newEventSystemMock()
+ eventSystem := evtMock.NewEventSystem()
ask.askEvents = newAskEvents(ask, eventSystem)
node := NewNode(proto)
// failure
node.preConditions(ask, true)
- assert.Equal(t, 1, len(eventSystem.events))
- assert.Equal(t, "Predicate failed for request 'test' with message:
'fake predicate plugin failed'", eventSystem.events[0].Message)
+ assert.Equal(t, 1, len(eventSystem.Events))
+ assert.Equal(t, "Predicate failed for request 'test' with message:
'fake predicate plugin failed'", eventSystem.Events[0].Message)
assert.Equal(t, 1, len(ask.allocLog))
assert.Equal(t, "fake predicate plugin failed", ask.allocLog["fake
predicate plugin failed"].Message)
@@ -838,6 +839,6 @@ func TestPreconditions(t *testing.T) {
eventSystem.Reset()
plugins.RegisterSchedulerPlugin(mock.NewPredicatePlugin(false,
map[string]int{}))
node.preConditions(ask, true)
- assert.Equal(t, 0, len(eventSystem.events))
+ assert.Equal(t, 0, len(eventSystem.Events))
assert.Equal(t, 1, len(ask.allocLog))
}
diff --git a/pkg/scheduler/objects/queue_events_test.go
b/pkg/scheduler/objects/queue_events_test.go
index 86014595..d36bf36d 100644
--- a/pkg/scheduler/objects/queue_events_test.go
+++ b/pkg/scheduler/objects/queue_events_test.go
@@ -25,6 +25,7 @@ import (
"github.com/apache/yunikorn-core/pkg/common"
"github.com/apache/yunikorn-core/pkg/common/resources"
+ "github.com/apache/yunikorn-core/pkg/events/mock"
"github.com/apache/yunikorn-scheduler-interface/lib/go/si"
)
@@ -37,16 +38,16 @@ func TestSendNewQueueEvent(t *testing.T) {
QueuePath: testQueuePath,
isManaged: true,
}
- mock := newEventSystemMockDisabled()
- nq := newQueueEvents(queue, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ nq := newQueueEvents(queue, eventSystem)
nq.sendNewQueueEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- nq = newQueueEvents(queue, mock)
+ eventSystem = mock.NewEventSystem()
+ nq = newQueueEvents(queue, eventSystem)
nq.sendNewQueueEvent()
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_QUEUE, event.Type)
assert.Equal(t, testQueuePath, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
@@ -54,13 +55,13 @@ func TestSendNewQueueEvent(t *testing.T) {
assert.Equal(t, si.EventRecord_ADD, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
assert.Equal(t, 0, len(event.Resource.Resources))
- mock = newEventSystemMock()
+ eventSystem = mock.NewEventSystem()
nq = newQueueEvents(&Queue{
QueuePath: testQueuePath,
isManaged: false,
- }, mock)
+ }, eventSystem)
nq.sendNewQueueEvent()
- event = mock.events[0]
+ event = eventSystem.Events[0]
assert.Equal(t, si.EventRecord_QUEUE_DYNAMIC, event.EventChangeDetail)
}
@@ -69,16 +70,16 @@ func TestSendRemoveQueueEvent(t *testing.T) {
QueuePath: testQueuePath,
isManaged: true,
}
- mock := newEventSystemMockDisabled()
- nq := newQueueEvents(queue, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ nq := newQueueEvents(queue, eventSystem)
nq.sendRemoveQueueEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- nq = newQueueEvents(queue, mock)
+ eventSystem = mock.NewEventSystem()
+ nq = newQueueEvents(queue, eventSystem)
nq.sendRemoveQueueEvent()
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_QUEUE, event.Type)
assert.Equal(t, testQueuePath, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
@@ -86,13 +87,13 @@ func TestSendRemoveQueueEvent(t *testing.T) {
assert.Equal(t, si.EventRecord_REMOVE, event.EventChangeType)
assert.Equal(t, si.EventRecord_DETAILS_NONE, event.EventChangeDetail)
assert.Equal(t, 0, len(event.Resource.Resources))
- mock = newEventSystemMock()
+ eventSystem = mock.NewEventSystem()
nq = newQueueEvents(&Queue{
QueuePath: testQueuePath,
isManaged: false,
- }, mock)
+ }, eventSystem)
nq.sendRemoveQueueEvent()
- event = mock.events[0]
+ event = eventSystem.Events[0]
assert.Equal(t, si.EventRecord_QUEUE_DYNAMIC, event.EventChangeDetail)
}
@@ -100,16 +101,16 @@ func TestNewApplicationEvent(t *testing.T) {
queue := &Queue{
QueuePath: testQueuePath,
}
- mock := newEventSystemMockDisabled()
- nq := newQueueEvents(queue, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ nq := newQueueEvents(queue, eventSystem)
nq.sendNewApplicationEvent(appID0)
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- nq = newQueueEvents(queue, mock)
+ eventSystem = mock.NewEventSystem()
+ nq = newQueueEvents(queue, eventSystem)
nq.sendNewApplicationEvent(appID0)
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_QUEUE, event.Type)
assert.Equal(t, testQueuePath, event.ObjectID)
assert.Equal(t, appID0, event.ReferenceID)
@@ -123,16 +124,16 @@ func TestRemoveApplicationEvent(t *testing.T) {
queue := &Queue{
QueuePath: testQueuePath,
}
- mock := newEventSystemMockDisabled()
- nq := newQueueEvents(queue, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ nq := newQueueEvents(queue, eventSystem)
nq.sendRemoveApplicationEvent(appID0)
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- nq = newQueueEvents(queue, mock)
+ eventSystem = mock.NewEventSystem()
+ nq = newQueueEvents(queue, eventSystem)
nq.sendRemoveApplicationEvent(appID0)
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_QUEUE, event.Type)
assert.Equal(t, testQueuePath, event.ObjectID)
assert.Equal(t, appID0, event.ReferenceID)
@@ -146,16 +147,16 @@ func TestTypeChangedEvent(t *testing.T) {
queue := &Queue{
QueuePath: testQueuePath,
}
- mock := newEventSystemMockDisabled()
- nq := newQueueEvents(queue, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ nq := newQueueEvents(queue, eventSystem)
nq.sendTypeChangedEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- nq = newQueueEvents(queue, mock)
+ eventSystem = mock.NewEventSystem()
+ nq = newQueueEvents(queue, eventSystem)
nq.sendTypeChangedEvent()
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_QUEUE, event.Type)
assert.Equal(t, testQueuePath, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
@@ -166,21 +167,21 @@ func TestTypeChangedEvent(t *testing.T) {
}
func TestSendMaxResourceChangedEvent(t *testing.T) {
- max := getTestResource()
+ maxRes :=
resources.NewResourceFromMap(map[string]resources.Quantity{"first": 1})
queue := &Queue{
QueuePath: testQueuePath,
- maxResource: max,
+ maxResource: maxRes,
}
- mock := newEventSystemMockDisabled()
- nq := newQueueEvents(queue, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ nq := newQueueEvents(queue, eventSystem)
nq.sendMaxResourceChangedEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- nq = newQueueEvents(queue, mock)
+ eventSystem = mock.NewEventSystem()
+ nq = newQueueEvents(queue, eventSystem)
nq.sendMaxResourceChangedEvent()
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_QUEUE, event.Type)
assert.Equal(t, testQueuePath, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
@@ -189,25 +190,25 @@ func TestSendMaxResourceChangedEvent(t *testing.T) {
assert.Equal(t, si.EventRecord_QUEUE_MAX, event.EventChangeDetail)
assert.Equal(t, 1, len(event.Resource.Resources))
protoRes := resources.NewResourceFromProto(event.Resource)
- assert.DeepEqual(t, max, protoRes)
+ assert.DeepEqual(t, maxRes, protoRes)
}
func TestSendGuaranteedResourceChangedEvent(t *testing.T) {
- guaranteed := getTestResource()
+ guaranteed :=
resources.NewResourceFromMap(map[string]resources.Quantity{"first": 1})
queue := &Queue{
QueuePath: testQueuePath,
guaranteedResource: guaranteed,
}
- mock := newEventSystemMockDisabled()
- nq := newQueueEvents(queue, mock)
+ eventSystem := mock.NewEventSystemDisabled()
+ nq := newQueueEvents(queue, eventSystem)
nq.sendGuaranteedResourceChangedEvent()
- assert.Equal(t, 0, len(mock.events), "unexpected event")
+ assert.Equal(t, 0, len(eventSystem.Events), "unexpected event")
- mock = newEventSystemMock()
- nq = newQueueEvents(queue, mock)
+ eventSystem = mock.NewEventSystem()
+ nq = newQueueEvents(queue, eventSystem)
nq.sendGuaranteedResourceChangedEvent()
- assert.Equal(t, 1, len(mock.events), "event was not generated")
- event := mock.events[0]
+ assert.Equal(t, 1, len(eventSystem.Events), "event was not generated")
+ event := eventSystem.Events[0]
assert.Equal(t, si.EventRecord_QUEUE, event.Type)
assert.Equal(t, testQueuePath, event.ObjectID)
assert.Equal(t, common.Empty, event.ReferenceID)
diff --git a/pkg/scheduler/objects/utilities_test.go
b/pkg/scheduler/objects/utilities_test.go
index bb2a6311..e66e4e98 100644
--- a/pkg/scheduler/objects/utilities_test.go
+++ b/pkg/scheduler/objects/utilities_test.go
@@ -23,6 +23,7 @@ import (
"testing"
"time"
+ "github.com/google/btree"
"gotest.tools/v3/assert"
"github.com/apache/yunikorn-core/pkg/common/configs"
@@ -275,3 +276,18 @@ func assertUserResourcesAndGroupResources(t *testing.T,
userGroup security.UserG
assert.Equal(t, resources.Equals(userResource, expectedUserResources),
true)
assert.Equal(t, resources.Equals(groupResource,
expectedGroupResources), true)
}
+
+func getNodeIteratorFn(nodes ...*Node) func() NodeIterator {
+ tree := btree.New(7)
+ for _, node := range nodes {
+ tree.ReplaceOrInsert(nodeRef{
+ node, 1,
+ })
+ }
+
+ return func() NodeIterator {
+ return NewTreeIterator(acceptAll, func() *btree.BTree {
+ return tree
+ })
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
