diff --git a/go.work.sum b/go.work.sum index 9c889caa8..3fe782b1f 100644 --- a/go.work.sum +++ b/go.work.sum @@ -923,6 +923,7 @@ github.com/machinebox/graphql v0.2.2/go.mod h1:F+kbVMHuwrQ5tYgU9JXlnskM8nOaFxCAE github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU= github.com/mattn/go-sqlite3 v1.14.7/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= +github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= github.com/mdlayher/netlink v1.4.0/go.mod h1:dRJi5IABcZpBD2A3D0Mv/AiX8I9uDEu5oGkAVrekmf8= github.com/mimuret/golang-iij-dpf v0.9.1/go.mod h1:sl9KyOkESib9+KRD3HaGpgi1xk7eoN2+d96LCLsME2M= @@ -973,9 +974,13 @@ github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzL github.com/pkg/profile v1.7.0/go.mod h1:8Uer0jas47ZQMJ7VD+OHknK4YDY07LPUC6dEvqDjvNo= github.com/pkg/xattr v0.4.1/go.mod h1:W2cGD0TBEus7MkUgv0tNZ9JutLtVO3cXu+IBRuHqnFs= github.com/pquerna/otp v1.4.0/go.mod h1:dkJfzwRKNiegxyNb54X/3fLwhCynbMspSyWKnvi1AEg= +github.com/prometheus/client_golang v1.17.0 h1:rl2sfwZMtSthVU752MqfjQozy7blglC+1SOtjMAMh+Q= github.com/prometheus/client_golang v1.17.0/go.mod h1:VeL+gMmOAxkS2IqfCq0ZmHSL+LjWfWDUmp1mBz9JgUY= +github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw= github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI= +github.com/prometheus/common v0.44.0 h1:+5BrQJwiBB9xsMygAB3TNvpQKOwlkc25LbISbrdOOfY= github.com/prometheus/common v0.44.0/go.mod h1:ofAIvZbQ1e/nugmZGz4/qCb9Ap1VoSTIO7x0VV9VvuY= +github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= github.com/rainycape/memcache v0.0.0-20150622160815-1031fa0ce2f2/go.mod h1:7tZKcyumwBO6qip7RNQ5r77yrssm9bfCowcLEBcU5IA= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= diff --git a/grid-proxy/go.mod b/grid-proxy/go.mod index d0746566a..8a40e490e 100644 --- a/grid-proxy/go.mod +++ b/grid-proxy/go.mod @@ -44,6 +44,7 @@ require ( github.com/go-openapi/swag v0.22.3 // indirect github.com/go-stack/stack v1.8.1 // indirect github.com/golang-jwt/jwt v3.2.2+incompatible // indirect + github.com/golang/mock v1.6.0 // indirect github.com/golang/protobuf v1.5.3 // indirect github.com/gomodule/redigo v2.0.0+incompatible // indirect github.com/gorilla/websocket v1.5.3 // indirect diff --git a/grid-proxy/go.sum b/grid-proxy/go.sum index eea6f2c59..92034aa4f 100644 --- a/grid-proxy/go.sum +++ b/grid-proxy/go.sum @@ -188,17 +188,20 @@ github.com/vedhavyas/go-subkey v1.0.3/go.mod h1:CloUaFQSSTdWnINfBRFjVMkWXZANW+nd github.com/vmihailenco/msgpack v4.0.3+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaUXK79GlxNBwueZn0xI= github.com/vmihailenco/msgpack v4.0.4+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= github.com/yusufpapurcu/wmi v1.2.2 h1:KBNDSne4vP5mbSWnJbO+51IMOXJB67QiYCSBrubbPRg= github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw= golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U= golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= @@ -209,17 +212,21 @@ golang.org/x/net v0.0.0-20190514140710-3ec191127204/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac= golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -242,11 +249,14 @@ golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190425163242-31fd60d6bfdc/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg= golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.15.0 h1:2lYxjRbTYyxkJxlhC+LvJIx3SsANPdRybu1tGj9/OrQ= gonum.org/v1/gonum v0.15.0/go.mod h1:xzZVBJBtS+Mz4q0Yl2LJTk+OxOg4jiXZ7qBoM0uISGo= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= diff --git a/grid-proxy/internal/indexer/dmi.go b/grid-proxy/internal/indexer/dmi.go index c6e9a4cb9..d5f1d7df1 100644 --- a/grid-proxy/internal/indexer/dmi.go +++ b/grid-proxy/internal/indexer/dmi.go @@ -6,7 +6,7 @@ import ( "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" - "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer" + "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go" zosDmiTypes "github.com/threefoldtech/zos/pkg/capacity/dmi" ) @@ -31,7 +31,7 @@ func (w *DMIWork) Finders() map[string]time.Duration { return w.findersInterval } -func (w *DMIWork) Get(ctx context.Context, rmb *peer.RpcClient, twinId uint32) ([]types.Dmi, error) { +func (w *DMIWork) Get(ctx context.Context, rmb rmb.Client, twinId uint32) ([]types.Dmi, error) { var dmi zosDmiTypes.DMI err := callNode(ctx, rmb, DmiCallCmd, nil, twinId, &dmi) if err != nil { diff --git a/grid-proxy/internal/indexer/dmi_test.go b/grid-proxy/internal/indexer/dmi_test.go new file mode 100644 index 000000000..77dfb7703 --- /dev/null +++ b/grid-proxy/internal/indexer/dmi_test.go @@ -0,0 +1,138 @@ +package indexer + +import ( + "context" + "testing" + "time" + + gomock "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + mock_rmb "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/mocks" + "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" + zosDmiTypes "github.com/threefoldtech/zos/pkg/capacity/dmi" +) + +func TestNewDMIWork(t *testing.T) { + wanted := &DMIWork{ + findersInterval: map[string]time.Duration{ + "up": 2 * time.Minute, + "new": 5 * time.Minute, + }, + } + dmi := NewDMIWork(2) + assert.Exactlyf(t, wanted, dmi, "got: %v , expected: %v", dmi, wanted) +} + +func TestDMIGet(t *testing.T) { + dmi := NewDMIWork(2) + ctrl := gomock.NewController(t) + ctx := context.Background() + + t.Run("get dmi with valid twin id", func(t *testing.T) { + twinID := uint32(1) + expected := zosDmiTypes.DMI{ + Sections: []zosDmiTypes.Section{ + { + TypeStr: "BIOS", + SubSections: []zosDmiTypes.SubSection{ + { + Title: "BIOS Information", + Properties: map[string]zosDmiTypes.PropertyData{ + "Vendor": {Val: "American Megatrends Inc."}, + "Version": {Val: "3.2"}, + }, + }, + }, + }, + { + TypeStr: "Baseboard", + SubSections: []zosDmiTypes.SubSection{ + { + Title: "Base Board Information", + Properties: map[string]zosDmiTypes.PropertyData{ + "Manufacturer": {Val: "Supermicro"}, + "Product Name": {Val: "X9DRi-LN4+/X9DR3-LN4+"}, + }, + }, + }, + }, + { + TypeStr: "Processor", + SubSections: []zosDmiTypes.SubSection{ + { + Title: "Processor Information", + Properties: map[string]zosDmiTypes.PropertyData{ + "Version": {Val: "Intel(R) Xeon(R) CPU E5-2620 0 @ 2.00GHz"}, + "Thread Count": {Val: "12"}, + }, + }, + { + Title: "Processor Information", + Properties: map[string]zosDmiTypes.PropertyData{ + "Version": {Val: "Intel(R) Xeon(R) CPU E5-2620 0 @ 2.00GHz"}, + "Thread Count": {Val: "12"}, + }, + }, + }, + }, + { + TypeStr: "MemoryDevice", + SubSections: []zosDmiTypes.SubSection{ + { + Title: "Memory Device", + Properties: map[string]zosDmiTypes.PropertyData{ + "Manufacturer": {Val: "Samsung"}, + "Type": {Val: "DDR3"}, + }, + }, + { + Title: "Memory Device", + Properties: map[string]zosDmiTypes.PropertyData{ + "Manufacturer": {Val: "Samsung"}, + "Type": {Val: "DDR3"}, + }, + }, + { + Title: "Memory Device", + Properties: map[string]zosDmiTypes.PropertyData{ + "Manufacturer": {Val: "Samsung"}, + "Type": {Val: "DDR3"}, + }, + }, + }, + }, + }, + } + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, DmiCallCmd, nil, &zosDmiTypes.DMI{}).DoAndReturn( + func(ctx context.Context, twin uint32, fn string, data, result interface{}) error { + *(result.(*zosDmiTypes.DMI)) = expected + return nil + }, + ) + got, err := dmi.Get(ctx, client, twinID) + assert.NoError(t, err) + assert.Len(t, got, 1) + assert.Equal(t, expected.Sections[0].SubSections[0].Properties["Vendor"].Val, got[0].BIOS.Vendor) + assert.Equal(t, expected.Sections[0].SubSections[0].Properties["Version"].Val, got[0].BIOS.Version) + assert.Equal(t, expected.Sections[1].SubSections[0].Properties["Manufacturer"].Val, got[0].Baseboard.Manufacturer) + assert.Equal(t, expected.Sections[1].SubSections[0].Properties["Product Name"].Val, got[0].Baseboard.ProductName) + assert.Equal(t, expected.Sections[2].SubSections[0].Properties["Version"].Val, got[0].Processor[0].Version) + assert.Equal(t, expected.Sections[2].SubSections[0].Properties["Thread Count"].Val, got[0].Processor[0].ThreadCount) + assert.Equal(t, expected.Sections[3].SubSections[0].Properties["Manufacturer"].Val, got[0].Memory[0].Manufacturer) + assert.Equal(t, expected.Sections[3].SubSections[0].Properties["Type"].Val, got[0].Memory[0].Type) + assert.IsTypef(t, got, []types.Dmi{}, "got: %T , expected: %T", got, []types.Dmi{}) + + }) + + t.Run("get dmi with invalid twin id", func(t *testing.T) { + twinID := uint32(2) + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, DmiCallCmd, nil, &zosDmiTypes.DMI{}).Return( + assert.AnError, + ) + _, err := dmi.Get(ctx, client, twinID) + assert.Error(t, err) + }) + +} diff --git a/grid-proxy/internal/indexer/features.go b/grid-proxy/internal/indexer/features.go index d1ddaf6a8..708d182f6 100644 --- a/grid-proxy/internal/indexer/features.go +++ b/grid-proxy/internal/indexer/features.go @@ -6,7 +6,7 @@ import ( "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" - "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer" + "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go" ) const ( @@ -30,7 +30,7 @@ func (w *FeatureWork) Finders() map[string]time.Duration { return w.findersInterval } -func (w *FeatureWork) Get(ctx context.Context, rmb *peer.RpcClient, twinId uint32) ([]types.NodeFeatures, error) { +func (w *FeatureWork) Get(ctx context.Context, rmb rmb.Client, twinId uint32) ([]types.NodeFeatures, error) { var features []string err := callNode(ctx, rmb, featuresCallCmd, nil, twinId, &features) if err != nil { diff --git a/grid-proxy/internal/indexer/features_test.go b/grid-proxy/internal/indexer/features_test.go new file mode 100644 index 000000000..c8b9dbb0a --- /dev/null +++ b/grid-proxy/internal/indexer/features_test.go @@ -0,0 +1,69 @@ +package indexer + +import ( + "context" + "testing" + "time" + + gomock "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + mock_rmb "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/mocks" + "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" +) + +func TestNewFeatureWork(t *testing.T) { + wanted := &FeatureWork{ + findersInterval: map[string]time.Duration{ + "up": time.Duration(2) * time.Minute, + "new": newNodesCheckInterval, + }, + } + feature := NewFeatureWork(2) + assert.Exactlyf(t, wanted, feature, "got: %v , expected: %v", feature, wanted) +} + +func TestFeatureGet(t *testing.T) { + feature := NewFeatureWork(2) + ctrl := gomock.NewController(t) + ctx := context.Background() + + t.Run("get feature with valid twin id", func(t *testing.T) { + twinID := uint32(1) + expected := []string{"zmount", "network", "zdb", "zmachine", "volume", "ipv4", + "ip", + "gateway-name-proxy", + "gateway-fqdn-proxy", + "qsfs", + "zlogs", + "yggdrasil", + "mycelium", + "wireguard"} + + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, featuresCallCmd, nil, gomock.Any()).DoAndReturn( + func(ctx context.Context, twinId uint32, fn string, data, result interface{}) error { + *result.(*[]string) = expected + return nil + }, + ) + features, err := feature.Get(ctx, client, twinID) + assert.NoError(t, err) + assert.Len(t, features, 1) + assert.Equal(t, expected, features[0].Features) + assert.Equal(t, twinID, features[0].NodeTwinId) + assert.IsTypef(t, features, []types.NodeFeatures{}, "got: %T , expected: %T", features, []types.NodeFeatures{}) + }) + + t.Run("get feature with invalid twin id", func(t *testing.T) { + twinID := uint32(1) + + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, featuresCallCmd, nil, gomock.Any()).Return( + assert.AnError, + ) + features, err := feature.Get(ctx, client, twinID) + assert.Error(t, err) + assert.Len(t, features, 0) + }) + +} diff --git a/grid-proxy/internal/indexer/finders_test.go b/grid-proxy/internal/indexer/finders_test.go new file mode 100644 index 000000000..05246e092 --- /dev/null +++ b/grid-proxy/internal/indexer/finders_test.go @@ -0,0 +1,125 @@ +package indexer + +import ( + "context" + "testing" + "time" + + gomock "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" + mocks "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/mocks" +) + +func TestNewNodeFinder(t *testing.T) { + ctrl := gomock.NewController(t) + + mockDB := mocks.NewMockDatabase(ctrl) + + idsChan := make(chan uint32, 10) + + mockDB.EXPECT().GetLastNodeTwinID(gomock.Any()).Return(uint32(1), nil).Times(1) + mockDB.EXPECT().GetNodeTwinIDsAfter(gomock.Any(), gomock.Any()).Return([]uint32{2, 3}, nil).Times(1) + + ctx, cancel := context.WithCancel(context.Background()) + + go newNodesFinder(ctx, time.Second, mockDB, idsChan) + + time.Sleep(1 * time.Second) + + cancel() + + var ids []uint32 + for { + select { + case id := <-idsChan: + ids = append(ids, id) + default: + goto done + } + } + +done: + + assert.Equal(t, []uint32{2, 3}, ids) + +} + +func TestHealthyNodesFinder(t *testing.T) { + ctrl := gomock.NewController(t) + mockDB := mocks.NewMockDatabase(ctrl) + + idsChan := make(chan uint32, 10) + + mockDB.EXPECT().GetHealthyNodeTwinIds(gomock.Any()).Return([]uint32{1, 2, 3}, nil).Times(1) + + ctx, cancel := context.WithCancel(context.Background()) + + go healthyNodesFinder(ctx, time.Second, mockDB, idsChan) + + time.Sleep(500 * time.Millisecond) + + cancel() + + var ids []uint32 + for { + select { + case id := <-idsChan: + ids = append(ids, id) + default: + goto done + } + } + +done: + + assert.Equal(t, []uint32{1, 2, 3}, ids) + assert.Len(t, ids, 3) + +} + +func TestUpNodesFinder(t *testing.T) { + ctrl := gomock.NewController(t) + mockDB := mocks.NewMockDatabase(ctrl) + + idsChan := make(chan uint32, 10) + + mockDB.EXPECT().GetNodes(gomock.Any(), gomock.Any(), gomock.Any()).Return([]db.Node{ + { + TwinID: 1, + NodeID: 1, + FarmID: 3, + FarmName: "farm", + }, + { + TwinID: 2, + NodeID: 2, + FarmID: 3, + FarmName: "farm", + }, + }, uint(2), nil) + + ctx, cancel := context.WithCancel(context.Background()) + + go upNodesFinder(ctx, time.Second, mockDB, idsChan) + + time.Sleep(500 * time.Millisecond) + + cancel() + + var ids []uint32 + for { + select { + case id := <-idsChan: + ids = append(ids, id) + default: + goto done + } + } + +done: + + assert.Equal(t, []uint32{1, 2}, ids) + assert.Len(t, ids, 2) + +} diff --git a/grid-proxy/internal/indexer/gpu.go b/grid-proxy/internal/indexer/gpu.go index 9c1873a29..531340860 100644 --- a/grid-proxy/internal/indexer/gpu.go +++ b/grid-proxy/internal/indexer/gpu.go @@ -7,7 +7,7 @@ import ( "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" - "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer" + "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go" ) const ( @@ -31,7 +31,7 @@ func (w *GPUWork) Finders() map[string]time.Duration { return w.findersInterval } -func (w *GPUWork) Get(ctx context.Context, rmb *peer.RpcClient, twinId uint32) ([]types.NodeGPU, error) { +func (w *GPUWork) Get(ctx context.Context, rmb rmb.Client, twinId uint32) ([]types.NodeGPU, error) { var gpus []types.NodeGPU err := callNode(ctx, rmb, gpuListCmd, nil, twinId, &gpus) if err != nil { diff --git a/grid-proxy/internal/indexer/gpu_test.go b/grid-proxy/internal/indexer/gpu_test.go new file mode 100644 index 000000000..65edffa5a --- /dev/null +++ b/grid-proxy/internal/indexer/gpu_test.go @@ -0,0 +1,67 @@ +package indexer + +import ( + "context" + "testing" + "time" + + gomock "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + mock_rmb "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/mocks" + "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" +) + +func TestNewGPUWork(t *testing.T) { + wanted := &GPUWork{ + findersInterval: map[string]time.Duration{ + "up": 2 * time.Minute, + "new": 5 * time.Minute, + }, + } + gpu := NewGPUWork(2) + assert.Exactlyf(t, wanted, gpu, "got: %v , expected: %v", gpu, wanted) +} + +func TestGPUGet(t *testing.T) { + gpu := NewGPUWork(2) + ctrl := gomock.NewController(t) + ctx := context.Background() + + t.Run("get gpu with valid twin id", func(t *testing.T) { + twinID := uint32(1) + expected := []types.NodeGPU{ + { + NodeTwinID: 1, + ID: "gpu-1", + Vendor: "NVIDIA", + Device: "RTX 3080", + Contract: 123, + UpdatedAt: 1234567890, + }, + } + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, gpuListCmd, nil, gomock.AssignableToTypeOf(&[]types.NodeGPU{})).DoAndReturn( + func(ctx context.Context, twin uint32, fn string, data, result interface{}) error { + *(result.(*[]types.NodeGPU)) = expected + return nil + }, + ) + got, err := gpu.Get(ctx, client, twinID) + + assert.NoError(t, err) + assert.Equal(t, expected, got) + assert.Len(t, got, 1) + assert.Equal(t, "gpu-1", got[0].ID) + assert.Equal(t, "NVIDIA", got[0].Vendor) + }) + + t.Run("get gpu with invalid twin id", func(t *testing.T) { + twinID := uint32(2) + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, gpuListCmd, nil, gomock.AssignableToTypeOf(&[]types.NodeGPU{})).Return( + assert.AnError, + ) + _, err := gpu.Get(ctx, client, twinID) + assert.Error(t, err) + }) +} diff --git a/grid-proxy/internal/indexer/health.go b/grid-proxy/internal/indexer/health.go index 20b416d67..91202b202 100644 --- a/grid-proxy/internal/indexer/health.go +++ b/grid-proxy/internal/indexer/health.go @@ -6,7 +6,7 @@ import ( "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" - "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer" + "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go" "github.com/threefoldtech/zos/pkg/diagnostics" ) @@ -31,7 +31,7 @@ func (w *HealthWork) Finders() map[string]time.Duration { return w.findersInterval } -func (w *HealthWork) Get(ctx context.Context, rmb *peer.RpcClient, twinId uint32) ([]types.HealthReport, error) { +func (w *HealthWork) Get(ctx context.Context, rmb rmb.Client, twinId uint32) ([]types.HealthReport, error) { var diagnostics diagnostics.Diagnostics _ = callNode(ctx, rmb, healthCallCmd, nil, twinId, &diagnostics) res := getHealthReport(diagnostics, twinId) diff --git a/grid-proxy/internal/indexer/health_test.go b/grid-proxy/internal/indexer/health_test.go new file mode 100644 index 000000000..477ddcb89 --- /dev/null +++ b/grid-proxy/internal/indexer/health_test.go @@ -0,0 +1,83 @@ +package indexer + +import ( + "context" + "testing" + "time" + + gomock "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + mock_rmb "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/mocks" + "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" + "github.com/threefoldtech/zos/pkg/diagnostics" +) + +func TestNewHealthWork(t *testing.T) { + wanted := &HealthWork{ + findersInterval: map[string]time.Duration{ + "up": 2 * time.Minute, + "healthy": 2 * time.Minute, + }, + } + health := NewHealthWork(2) + assert.Exactlyf(t, wanted, health, "got: %v , expected: %v", health, wanted) +} + +func TestHealthGet(t *testing.T) { + health := NewHealthWork(2) + ctrl := gomock.NewController(t) + ctx := context.Background() + + t.Run("get health with valid twin id", func(t *testing.T) { + twinID := uint32(1) + expected := []types.HealthReport{ + { + NodeTwinId: 1, + Healthy: true, + UpdatedAt: time.Now().Unix(), + }, + } + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, healthCallCmd, nil, gomock.AssignableToTypeOf(&diagnostics.Diagnostics{})).DoAndReturn( + func(ctx context.Context, twin uint32, fn string, data, result interface{}) error { + diag := result.(*diagnostics.Diagnostics) + diag.Healthy = true + return nil + }, + ) + got, err := health.Get(ctx, client, twinID) + + assert.NoError(t, err) + assert.Equal(t, expected[0].NodeTwinId, got[0].NodeTwinId) + assert.Equal(t, expected[0].Healthy, got[0].Healthy) + assert.Len(t, got, 1) + }) + + t.Run("get health with invalid twin id", func(t *testing.T) { + twinID := uint32(2) + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, healthCallCmd, nil, gomock.AssignableToTypeOf(&diagnostics.Diagnostics{})).Return( + assert.AnError, + ) + got, _ := health.Get(ctx, client, twinID) + // we expect an error here because the twin id is invalid but the implementation ignore errors + //assert.Error(t, err) + assert.Len(t, got, 1) + assert.False(t, got[0].Healthy) + }) +} + +func TestRemoveDuplicates(t *testing.T) { + reports := []types.HealthReport{ + {NodeTwinId: 1, Healthy: true}, + {NodeTwinId: 2, Healthy: false}, + {NodeTwinId: 1, Healthy: true}, //Duplicate + {NodeTwinId: 3, Healthy: true}, + } + + result := removeDuplicates(reports) + assert.Len(t, result, 3) + assert.Contains(t, result, reports[0]) + assert.Contains(t, result, reports[1]) + assert.Contains(t, result, reports[3]) +} diff --git a/grid-proxy/internal/indexer/indexer.go b/grid-proxy/internal/indexer/indexer.go index bcc48ff4c..8631c914a 100644 --- a/grid-proxy/internal/indexer/indexer.go +++ b/grid-proxy/internal/indexer/indexer.go @@ -7,7 +7,7 @@ import ( "github.com/rs/zerolog/log" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" - "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer" + "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go" ) const ( @@ -19,7 +19,7 @@ const ( type Work[T any] interface { Finders() map[string]time.Duration - Get(ctx context.Context, rmb *peer.RpcClient, id uint32) ([]T, error) + Get(ctx context.Context, rmb rmb.Client, id uint32) ([]T, error) Upsert(ctx context.Context, db db.Database, batch []T) error } @@ -27,7 +27,7 @@ type Indexer[T any] struct { name string work Work[T] dbClient db.Database - rmbClient *peer.RpcClient + rmbClient rmb.Client idChan chan uint32 resultChan chan T batchChan chan []T @@ -38,7 +38,7 @@ func NewIndexer[T any]( work Work[T], name string, db db.Database, - rmb *peer.RpcClient, + rmb rmb.Client, worker uint, ) *Indexer[T] { return &Indexer[T]{ diff --git a/grid-proxy/internal/indexer/ipv6.go b/grid-proxy/internal/indexer/ipv6.go index b2abba6ff..e422e3956 100644 --- a/grid-proxy/internal/indexer/ipv6.go +++ b/grid-proxy/internal/indexer/ipv6.go @@ -6,7 +6,7 @@ import ( "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" - "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer" + "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go" ) const cmd = "zos.network.has_ipv6" @@ -29,7 +29,7 @@ func (w *Ipv6Work) Finders() map[string]time.Duration { return w.finders } -func (w *Ipv6Work) Get(ctx context.Context, rmb *peer.RpcClient, id uint32) ([]types.HasIpv6, error) { +func (w *Ipv6Work) Get(ctx context.Context, rmb rmb.Client, id uint32) ([]types.HasIpv6, error) { var has_ipv6 bool if err := callNode(ctx, rmb, cmd, nil, id, &has_ipv6); err != nil { return []types.HasIpv6{}, nil diff --git a/grid-proxy/internal/indexer/ipv6_test.go b/grid-proxy/internal/indexer/ipv6_test.go new file mode 100644 index 000000000..02d52fde7 --- /dev/null +++ b/grid-proxy/internal/indexer/ipv6_test.go @@ -0,0 +1,64 @@ +package indexer + +import ( + "context" + "testing" + "time" + + gomock "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + mock_rmb "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/mocks" + "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" +) + +func TestNewIpv6Work(t *testing.T) { + wanted := &Ipv6Work{ + finders: map[string]time.Duration{ + "up": 2 * time.Minute, + }, + } + ipv6 := NewIpv6Work(2) + assert.Exactlyf(t, wanted, ipv6, "got: %v , expected: %v", ipv6, wanted) +} + +func TestIpv6Get(t *testing.T) { + ipv6 := NewIpv6Work(2) + ctrl := gomock.NewController(t) + ctx := context.Background() + + t.Run("get ipv6 with valid twin id", func(t *testing.T) { + twinID := uint32(1) + expected := []types.HasIpv6{ + { + NodeTwinId: 1, + HasIpv6: true, + UpdatedAt: time.Now().Unix(), + }, + } + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, cmd, nil, gomock.Any()).DoAndReturn( + func(ctx context.Context, twin uint32, fn string, data, result interface{}) error { + *(result.(*bool)) = true + return nil + }, + ) + got, err := ipv6.Get(ctx, client, twinID) + + assert.NoError(t, err) + assert.Equal(t, expected[0].NodeTwinId, got[0].NodeTwinId) + assert.Equal(t, expected[0].HasIpv6, got[0].HasIpv6) + assert.Len(t, got, 1) + }) + + t.Run("get ipv6 with invalid twin id", func(t *testing.T) { + twinID := uint32(2) + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, cmd, nil, gomock.Any()).Return( + assert.AnError, + ) + got, _ := ipv6.Get(ctx, client, twinID) + // we expect an error here because the twin id is invalid but the implementation ignore errors + //assert.NoError(t, err) + assert.Empty(t, got) + }) +} diff --git a/grid-proxy/internal/indexer/speed.go b/grid-proxy/internal/indexer/speed.go index 14b256f4d..5f4cb7585 100644 --- a/grid-proxy/internal/indexer/speed.go +++ b/grid-proxy/internal/indexer/speed.go @@ -7,7 +7,7 @@ import ( "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" - "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer" + "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go" ) const ( @@ -57,7 +57,7 @@ func (w *SpeedWork) Finders() map[string]time.Duration { return w.findersInterval } -func (w *SpeedWork) Get(ctx context.Context, rmb *peer.RpcClient, twinId uint32) ([]types.Speed, error) { +func (w *SpeedWork) Get(ctx context.Context, rmb rmb.Client, twinId uint32) ([]types.Speed, error) { payload := struct { Name string }{ diff --git a/grid-proxy/internal/indexer/speed_test.go b/grid-proxy/internal/indexer/speed_test.go new file mode 100644 index 000000000..ee26d9993 --- /dev/null +++ b/grid-proxy/internal/indexer/speed_test.go @@ -0,0 +1,70 @@ +package indexer + +import ( + "context" + "testing" + "time" + + gomock "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + mocks "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/mocks" + types "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" +) + +func TestNewSpeedWork(t *testing.T) { + wanted := &SpeedWork{ + findersInterval: map[string]time.Duration{ + "up": 2 * time.Minute, + }, + } + speed := NewSpeedWork(2) + assert.Exactlyf(t, wanted, speed, "got: %v , expected: %v", speed, wanted) +} + +func TestSpeedGet(t *testing.T) { + speed := NewSpeedWork(2) + ctrl := gomock.NewController(t) + t.Run("get speed with valid twin id", func(t *testing.T) { + twinID := uint32(1) + expected := TaskResult{ + Name: "iperf", + Result: []IperfResult{{ + UploadSpeed: float64(200), + DownloadSpeed: float64(100), + NodeID: uint32(1), + CpuReport: CPUUtilizationPercent{ + HostTotal: float64(3), + HostUser: float64(1), + HostSystem: float64(2), + RemoteTotal: float64(3), + RemoteUser: float64(1), + RemoteSystem: float64(2), + }, + }, + }, + } + client := mocks.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, perfTestCallCmd, gomock.Any(), gomock.Any()).DoAndReturn( + func(ctx context.Context, twin uint32, fn string, data, result interface{}) error { + *(result.(*TaskResult)) = expected + return nil + }, + ) + got, err := speed.Get(context.Background(), client, twinID) + assert.NoError(t, err) + assert.Len(t, got, 1) + assert.IsTypef(t, got, []types.Speed{}, "got: %v , expected: %v", got, []types.Speed{}) + assert.Exactlyf(t, got[0].Upload, expected.Result.([]IperfResult)[0].UploadSpeed, "got: %v , expected: %v", got[0].Upload, expected.Result.([]IperfResult)[0].UploadSpeed) + assert.Exactlyf(t, got[0].Download, expected.Result.([]IperfResult)[0].DownloadSpeed, "got: %v , expected: %v", got[0].Download, expected.Result.([]IperfResult)[0].DownloadSpeed) + assert.Exactlyf(t, got[0].NodeTwinId, twinID, "got: %v , expected: %v", got[0].NodeTwinId, twinID) + }) + + t.Run("get speed with invalid twin id", func(t *testing.T) { + twinID := uint32(1) + client := mocks.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, perfTestCallCmd, gomock.Any(), gomock.Any()).Return(assert.AnError) + got, err := speed.Get(context.Background(), client, twinID) + assert.Error(t, err) + assert.Len(t, got, 0) + }) +} diff --git a/grid-proxy/internal/indexer/utils.go b/grid-proxy/internal/indexer/utils.go index 5035b91fe..320cb8f70 100644 --- a/grid-proxy/internal/indexer/utils.go +++ b/grid-proxy/internal/indexer/utils.go @@ -6,7 +6,7 @@ import ( "github.com/rs/zerolog/log" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" - "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer" + "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go" ) func queryUpNodes(ctx context.Context, database db.Database, nodeTwinIdChan chan uint32) { @@ -44,7 +44,7 @@ func queryHealthyNodes(ctx context.Context, database db.Database, nodeTwinIdChan } } -func callNode(ctx context.Context, rmbClient *peer.RpcClient, cmd string, payload interface{}, twinId uint32, result interface{}) error { +func callNode(ctx context.Context, rmbClient rmb.Client, cmd string, payload interface{}, twinId uint32, result interface{}) error { subCtx, cancel := context.WithTimeout(ctx, indexerCallTimeout) defer cancel() diff --git a/grid-proxy/internal/indexer/workload.go b/grid-proxy/internal/indexer/workload.go index d1a3f4bdd..3cf42acb1 100644 --- a/grid-proxy/internal/indexer/workload.go +++ b/grid-proxy/internal/indexer/workload.go @@ -6,7 +6,7 @@ import ( "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" - "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer" + "github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go" ) const ( @@ -29,7 +29,7 @@ func (w *WorkloadWork) Finders() map[string]time.Duration { return w.findersInterval } -func (w *WorkloadWork) Get(ctx context.Context, rmb *peer.RpcClient, twinId uint32) ([]types.NodesWorkloads, error) { +func (w *WorkloadWork) Get(ctx context.Context, rmb rmb.Client, twinId uint32) ([]types.NodesWorkloads, error) { var response struct { Users struct { Workloads uint32 `json:"workloads"` diff --git a/grid-proxy/internal/indexer/workload_test.go b/grid-proxy/internal/indexer/workload_test.go new file mode 100644 index 000000000..b010f0014 --- /dev/null +++ b/grid-proxy/internal/indexer/workload_test.go @@ -0,0 +1,68 @@ +package indexer + +import ( + "context" + "errors" + "testing" + "time" + + gomock "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + mock_rmb "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/mocks" + "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" +) + +func TextNewWorkloadWork(t *testing.T) { + wanted := &WorkloadWork{ + findersInterval: map[string]time.Duration{ + "up": time.Duration(2) * time.Minute, + }, + } + workload := NewWorkloadWork(2) + assert.Exactly(t, wanted, workload) +} + +func TestWorkloadGet(t *testing.T) { + workload := NewWorkloadWork(2) + ctrl := gomock.NewController(t) + + t.Run("get workload with valid twin id", func(t *testing.T) { + twinID := uint32(1) + var response struct { + Users struct { + Workloads uint32 `json:"workloads"` + } `json:"users"` + } + ctx := context.Background() + + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, statsCall, nil, gomock.Any()).DoAndReturn( + func(ctx context.Context, twinId uint32, fn string, data, result interface{}) error { + response.Users.Workloads = 10 + *result.(*struct { + Users struct { + Workloads uint32 `json:"workloads"` + } `json:"users"` + }) = response + return nil + }, + ) + workloads, err := workload.Get(ctx, client, twinID) + assert.NoError(t, err) + assert.Len(t, workloads, 1) + assert.Equal(t, response.Users.Workloads, workloads[0].WorkloadsNumber) + assert.Equal(t, twinID, workloads[0].NodeTwinId) + assert.IsType(t, workloads, []types.NodesWorkloads{}) + }) + + t.Run("get workload with invalid twin id", func(t *testing.T) { + twinID := uint32(1) + ctx := context.Background() + + client := mock_rmb.NewMockClient(ctrl) + client.EXPECT().Call(gomock.Any(), twinID, statsCall, nil, gomock.Any()).Return(errors.New("error")) + workloads, err := workload.Get(ctx, client, twinID) + assert.Error(t, err) + assert.Len(t, workloads, 0) + }) +} diff --git a/grid-proxy/mocks/db_mock.go b/grid-proxy/mocks/db_mock.go new file mode 100644 index 000000000..42c93ad99 --- /dev/null +++ b/grid-proxy/mocks/db_mock.go @@ -0,0 +1,457 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: grid-proxy/internal/explorer/db/types.go +// +// Generated by this command: +// +// mockgen -destination=grid-proxy/mocks/db_mock.go -source=grid-proxy/internal/explorer/db/types.go +// + +// Package mock_db is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + db "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/internal/explorer/db" + types "github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types" + gomock "github.com/golang/mock/gomock" +) + +// MockDatabase is a mock of Database interface. +type MockDatabase struct { + ctrl *gomock.Controller + recorder *MockDatabaseMockRecorder +} + +// MockDatabaseMockRecorder is the mock recorder for MockDatabase. +type MockDatabaseMockRecorder struct { + mock *MockDatabase +} + +// NewMockDatabase creates a new mock instance. +func NewMockDatabase(ctrl *gomock.Controller) *MockDatabase { + mock := &MockDatabase{ctrl: ctrl} + mock.recorder = &MockDatabaseMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockDatabase) EXPECT() *MockDatabaseMockRecorder { + return m.recorder +} + +// DeleteOldGpus mocks base method. +func (m *MockDatabase) DeleteOldGpus(ctx context.Context, nodeTwinIds []uint32, expiration int64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteOldGpus", ctx, nodeTwinIds, expiration) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteOldGpus indicates an expected call of DeleteOldGpus. +func (mr *MockDatabaseMockRecorder) DeleteOldGpus(ctx, nodeTwinIds, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldGpus", reflect.TypeOf((*MockDatabase)(nil).DeleteOldGpus), ctx, nodeTwinIds, expiration) +} + +// GetConnectionString mocks base method. +func (m *MockDatabase) GetConnectionString() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetConnectionString") + ret0, _ := ret[0].(string) + return ret0 +} + +// GetConnectionString indicates an expected call of GetConnectionString. +func (mr *MockDatabaseMockRecorder) GetConnectionString() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectionString", reflect.TypeOf((*MockDatabase)(nil).GetConnectionString)) +} + +// GetContract mocks base method. +func (m *MockDatabase) GetContract(ctx context.Context, contractID uint32) (db.DBContract, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContract", ctx, contractID) + ret0, _ := ret[0].(db.DBContract) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetContract indicates an expected call of GetContract. +func (mr *MockDatabaseMockRecorder) GetContract(ctx, contractID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContract", reflect.TypeOf((*MockDatabase)(nil).GetContract), ctx, contractID) +} + +// GetContractBills mocks base method. +func (m *MockDatabase) GetContractBills(ctx context.Context, contractID uint32, limit types.Limit) ([]db.ContractBilling, uint, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContractBills", ctx, contractID, limit) + ret0, _ := ret[0].([]db.ContractBilling) + ret1, _ := ret[1].(uint) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetContractBills indicates an expected call of GetContractBills. +func (mr *MockDatabaseMockRecorder) GetContractBills(ctx, contractID, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContractBills", reflect.TypeOf((*MockDatabase)(nil).GetContractBills), ctx, contractID, limit) +} + +// GetContracts mocks base method. +func (m *MockDatabase) GetContracts(ctx context.Context, filter types.ContractFilter, limit types.Limit) ([]db.DBContract, uint, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContracts", ctx, filter, limit) + ret0, _ := ret[0].([]db.DBContract) + ret1, _ := ret[1].(uint) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetContracts indicates an expected call of GetContracts. +func (mr *MockDatabaseMockRecorder) GetContracts(ctx, filter, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContracts", reflect.TypeOf((*MockDatabase)(nil).GetContracts), ctx, filter, limit) +} + +// GetContractsLatestBillReports mocks base method. +func (m *MockDatabase) GetContractsLatestBillReports(ctx context.Context, contractsIds []uint32, limit uint) ([]db.ContractBilling, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContractsLatestBillReports", ctx, contractsIds, limit) + ret0, _ := ret[0].([]db.ContractBilling) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetContractsLatestBillReports indicates an expected call of GetContractsLatestBillReports. +func (mr *MockDatabaseMockRecorder) GetContractsLatestBillReports(ctx, contractsIds, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContractsLatestBillReports", reflect.TypeOf((*MockDatabase)(nil).GetContractsLatestBillReports), ctx, contractsIds, limit) +} + +// GetContractsTotalBilledAmount mocks base method. +func (m *MockDatabase) GetContractsTotalBilledAmount(ctx context.Context, contractIds []uint32) (uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetContractsTotalBilledAmount", ctx, contractIds) + ret0, _ := ret[0].(uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetContractsTotalBilledAmount indicates an expected call of GetContractsTotalBilledAmount. +func (mr *MockDatabaseMockRecorder) GetContractsTotalBilledAmount(ctx, contractIds any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContractsTotalBilledAmount", reflect.TypeOf((*MockDatabase)(nil).GetContractsTotalBilledAmount), ctx, contractIds) +} + +// GetFarm mocks base method. +func (m *MockDatabase) GetFarm(ctx context.Context, farmID uint32) (db.Farm, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFarm", ctx, farmID) + ret0, _ := ret[0].(db.Farm) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFarm indicates an expected call of GetFarm. +func (mr *MockDatabaseMockRecorder) GetFarm(ctx, farmID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFarm", reflect.TypeOf((*MockDatabase)(nil).GetFarm), ctx, farmID) +} + +// GetFarms mocks base method. +func (m *MockDatabase) GetFarms(ctx context.Context, filter types.FarmFilter, limit types.Limit) ([]db.Farm, uint, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFarms", ctx, filter, limit) + ret0, _ := ret[0].([]db.Farm) + ret1, _ := ret[1].(uint) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetFarms indicates an expected call of GetFarms. +func (mr *MockDatabaseMockRecorder) GetFarms(ctx, filter, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFarms", reflect.TypeOf((*MockDatabase)(nil).GetFarms), ctx, filter, limit) +} + +// GetHealthyNodeTwinIds mocks base method. +func (m *MockDatabase) GetHealthyNodeTwinIds(ctx context.Context) ([]uint32, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetHealthyNodeTwinIds", ctx) + ret0, _ := ret[0].([]uint32) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetHealthyNodeTwinIds indicates an expected call of GetHealthyNodeTwinIds. +func (mr *MockDatabaseMockRecorder) GetHealthyNodeTwinIds(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthyNodeTwinIds", reflect.TypeOf((*MockDatabase)(nil).GetHealthyNodeTwinIds), ctx) +} + +// GetLastNodeTwinID mocks base method. +func (m *MockDatabase) GetLastNodeTwinID(ctx context.Context) (uint32, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLastNodeTwinID", ctx) + ret0, _ := ret[0].(uint32) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLastNodeTwinID indicates an expected call of GetLastNodeTwinID. +func (mr *MockDatabaseMockRecorder) GetLastNodeTwinID(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastNodeTwinID", reflect.TypeOf((*MockDatabase)(nil).GetLastNodeTwinID), ctx) +} + +// GetLastUpsertsTimestamp mocks base method. +func (m *MockDatabase) GetLastUpsertsTimestamp() (types.IndexersState, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLastUpsertsTimestamp") + ret0, _ := ret[0].(types.IndexersState) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLastUpsertsTimestamp indicates an expected call of GetLastUpsertsTimestamp. +func (mr *MockDatabaseMockRecorder) GetLastUpsertsTimestamp() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastUpsertsTimestamp", reflect.TypeOf((*MockDatabase)(nil).GetLastUpsertsTimestamp)) +} + +// GetNode mocks base method. +func (m *MockDatabase) GetNode(ctx context.Context, nodeID uint32) (db.Node, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNode", ctx, nodeID) + ret0, _ := ret[0].(db.Node) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetNode indicates an expected call of GetNode. +func (mr *MockDatabaseMockRecorder) GetNode(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNode", reflect.TypeOf((*MockDatabase)(nil).GetNode), ctx, nodeID) +} + +// GetNodeTwinIDsAfter mocks base method. +func (m *MockDatabase) GetNodeTwinIDsAfter(ctx context.Context, twinID uint32) ([]uint32, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNodeTwinIDsAfter", ctx, twinID) + ret0, _ := ret[0].([]uint32) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetNodeTwinIDsAfter indicates an expected call of GetNodeTwinIDsAfter. +func (mr *MockDatabaseMockRecorder) GetNodeTwinIDsAfter(ctx, twinID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeTwinIDsAfter", reflect.TypeOf((*MockDatabase)(nil).GetNodeTwinIDsAfter), ctx, twinID) +} + +// GetNodes mocks base method. +func (m *MockDatabase) GetNodes(ctx context.Context, filter types.NodeFilter, limit types.Limit) ([]db.Node, uint, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNodes", ctx, filter, limit) + ret0, _ := ret[0].([]db.Node) + ret1, _ := ret[1].(uint) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetNodes indicates an expected call of GetNodes. +func (mr *MockDatabaseMockRecorder) GetNodes(ctx, filter, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodes", reflect.TypeOf((*MockDatabase)(nil).GetNodes), ctx, filter, limit) +} + +// GetPublicIps mocks base method. +func (m *MockDatabase) GetPublicIps(ctx context.Context, filter types.PublicIpFilter, limit types.Limit) ([]types.PublicIP, uint, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPublicIps", ctx, filter, limit) + ret0, _ := ret[0].([]types.PublicIP) + ret1, _ := ret[1].(uint) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetPublicIps indicates an expected call of GetPublicIps. +func (mr *MockDatabaseMockRecorder) GetPublicIps(ctx, filter, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicIps", reflect.TypeOf((*MockDatabase)(nil).GetPublicIps), ctx, filter, limit) +} + +// GetRandomHealthyTwinIds mocks base method. +func (m *MockDatabase) GetRandomHealthyTwinIds(length int) ([]uint32, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRandomHealthyTwinIds", length) + ret0, _ := ret[0].([]uint32) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRandomHealthyTwinIds indicates an expected call of GetRandomHealthyTwinIds. +func (mr *MockDatabaseMockRecorder) GetRandomHealthyTwinIds(length any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRandomHealthyTwinIds", reflect.TypeOf((*MockDatabase)(nil).GetRandomHealthyTwinIds), length) +} + +// GetStats mocks base method. +func (m *MockDatabase) GetStats(ctx context.Context, filter types.StatsFilter) (types.Stats, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetStats", ctx, filter) + ret0, _ := ret[0].(types.Stats) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetStats indicates an expected call of GetStats. +func (mr *MockDatabaseMockRecorder) GetStats(ctx, filter any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStats", reflect.TypeOf((*MockDatabase)(nil).GetStats), ctx, filter) +} + +// GetTwins mocks base method. +func (m *MockDatabase) GetTwins(ctx context.Context, filter types.TwinFilter, limit types.Limit) ([]types.Twin, uint, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTwins", ctx, filter, limit) + ret0, _ := ret[0].([]types.Twin) + ret1, _ := ret[1].(uint) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetTwins indicates an expected call of GetTwins. +func (mr *MockDatabaseMockRecorder) GetTwins(ctx, filter, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTwins", reflect.TypeOf((*MockDatabase)(nil).GetTwins), ctx, filter, limit) +} + +// Initialized mocks base method. +func (m *MockDatabase) Initialized() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Initialized") + ret0, _ := ret[0].(error) + return ret0 +} + +// Initialized indicates an expected call of Initialized. +func (mr *MockDatabaseMockRecorder) Initialized() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialized", reflect.TypeOf((*MockDatabase)(nil).Initialized)) +} + +// Ping mocks base method. +func (m *MockDatabase) Ping() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Ping") + ret0, _ := ret[0].(error) + return ret0 +} + +// Ping indicates an expected call of Ping. +func (mr *MockDatabaseMockRecorder) Ping() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockDatabase)(nil).Ping)) +} + +// UpsertNetworkSpeed mocks base method. +func (m *MockDatabase) UpsertNetworkSpeed(ctx context.Context, speeds []types.Speed) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNetworkSpeed", ctx, speeds) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNetworkSpeed indicates an expected call of UpsertNetworkSpeed. +func (mr *MockDatabaseMockRecorder) UpsertNetworkSpeed(ctx, speeds any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNetworkSpeed", reflect.TypeOf((*MockDatabase)(nil).UpsertNetworkSpeed), ctx, speeds) +} + +// UpsertNodeDmi mocks base method. +func (m *MockDatabase) UpsertNodeDmi(ctx context.Context, dmis []types.Dmi) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNodeDmi", ctx, dmis) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNodeDmi indicates an expected call of UpsertNodeDmi. +func (mr *MockDatabaseMockRecorder) UpsertNodeDmi(ctx, dmis any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeDmi", reflect.TypeOf((*MockDatabase)(nil).UpsertNodeDmi), ctx, dmis) +} + +// UpsertNodeFeatures mocks base method. +func (m *MockDatabase) UpsertNodeFeatures(ctx context.Context, features []types.NodeFeatures) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNodeFeatures", ctx, features) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNodeFeatures indicates an expected call of UpsertNodeFeatures. +func (mr *MockDatabaseMockRecorder) UpsertNodeFeatures(ctx, features any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeFeatures", reflect.TypeOf((*MockDatabase)(nil).UpsertNodeFeatures), ctx, features) +} + +// UpsertNodeHealth mocks base method. +func (m *MockDatabase) UpsertNodeHealth(ctx context.Context, healthReports []types.HealthReport) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNodeHealth", ctx, healthReports) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNodeHealth indicates an expected call of UpsertNodeHealth. +func (mr *MockDatabaseMockRecorder) UpsertNodeHealth(ctx, healthReports any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeHealth", reflect.TypeOf((*MockDatabase)(nil).UpsertNodeHealth), ctx, healthReports) +} + +// UpsertNodeIpv6Report mocks base method. +func (m *MockDatabase) UpsertNodeIpv6Report(ctx context.Context, ips []types.HasIpv6) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNodeIpv6Report", ctx, ips) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNodeIpv6Report indicates an expected call of UpsertNodeIpv6Report. +func (mr *MockDatabaseMockRecorder) UpsertNodeIpv6Report(ctx, ips any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeIpv6Report", reflect.TypeOf((*MockDatabase)(nil).UpsertNodeIpv6Report), ctx, ips) +} + +// UpsertNodeWorkloads mocks base method. +func (m *MockDatabase) UpsertNodeWorkloads(ctx context.Context, workloads []types.NodesWorkloads) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNodeWorkloads", ctx, workloads) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNodeWorkloads indicates an expected call of UpsertNodeWorkloads. +func (mr *MockDatabaseMockRecorder) UpsertNodeWorkloads(ctx, workloads any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodeWorkloads", reflect.TypeOf((*MockDatabase)(nil).UpsertNodeWorkloads), ctx, workloads) +} + +// UpsertNodesGPU mocks base method. +func (m *MockDatabase) UpsertNodesGPU(ctx context.Context, gpus []types.NodeGPU) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpsertNodesGPU", ctx, gpus) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpsertNodesGPU indicates an expected call of UpsertNodesGPU. +func (mr *MockDatabaseMockRecorder) UpsertNodesGPU(ctx, gpus any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNodesGPU", reflect.TypeOf((*MockDatabase)(nil).UpsertNodesGPU), ctx, gpus) +} diff --git a/grid-proxy/mocks/rmb_client_mock.go b/grid-proxy/mocks/rmb_client_mock.go new file mode 100644 index 000000000..613330691 --- /dev/null +++ b/grid-proxy/mocks/rmb_client_mock.go @@ -0,0 +1,79 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: rmb-sdk-go/interface.go +// +// Generated by this command: +// +// mockgen -source=rmb-sdk-go/interface.go -destination=grid-proxy/mocks/rmb_client_mock.go -typed +// + +// Package mock_rmb is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + + +// MockClient is a mock of Client interface. +type MockClient struct { + ctrl *gomock.Controller + recorder *MockClientMockRecorder +} + +// MockClientMockRecorder is the mock recorder for MockClient. +type MockClientMockRecorder struct { + mock *MockClient +} + +// NewMockClient creates a new mock instance. +func NewMockClient(ctrl *gomock.Controller) *MockClient { + mock := &MockClient{ctrl: ctrl} + mock.recorder = &MockClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder +} + +// Call mocks base method. +func (m *MockClient) Call(ctx context.Context, twin uint32, fn string, data, result any) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Call", ctx, twin, fn, data, result) + ret0, _ := ret[0].(error) + return ret0 +} + +// Call indicates an expected call of Call. +func (mr *MockClientMockRecorder) Call(ctx, twin, fn, data, result any) *MockClientCallCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockClient)(nil).Call), ctx, twin, fn, data, result) + return &MockClientCallCall{Call: call} +} + +// MockClientCallCall wrap *gomock.Call +type MockClientCallCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockClientCallCall) Return(arg0 error) *MockClientCallCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockClientCallCall) Do(f func(context.Context, uint32, string, any, any) error) *MockClientCallCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockClientCallCall) DoAndReturn(f func(context.Context, uint32, string, any, any) error) *MockClientCallCall { + c.Call = c.Call.DoAndReturn(f) + return c +}