267 lines
9.0 KiB
Go
267 lines
9.0 KiB
Go
// Copyright (C) 2019 Storj Labs, Inc.
|
|
// See LICENSE for copying information.
|
|
|
|
package overlay_test
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"storj.io/storj/internal/testcontext"
|
|
"storj.io/storj/pkg/overlay"
|
|
"storj.io/storj/pkg/pb"
|
|
"storj.io/storj/pkg/storj"
|
|
"storj.io/storj/satellite"
|
|
"storj.io/storj/satellite/satellitedb/satellitedbtest"
|
|
)
|
|
|
|
func getRatio(success, total int64) (ratio float64) {
|
|
ratio = float64(success) / float64(total)
|
|
return ratio
|
|
}
|
|
|
|
func TestStatDB(t *testing.T) {
|
|
t.Skip("team green skipped until V3-1843 is implemented")
|
|
satellitedbtest.Run(t, func(t *testing.T, db satellite.DB) {
|
|
ctx := testcontext.New(t)
|
|
defer ctx.Cleanup()
|
|
|
|
testDatabase(ctx, t, db.OverlayCache())
|
|
})
|
|
}
|
|
|
|
func testDatabase(ctx context.Context, t *testing.T, cache overlay.DB) {
|
|
nodeID := storj.NodeID{1, 2, 3, 4, 5}
|
|
currAuditSuccess := int64(4)
|
|
currAuditCount := int64(10)
|
|
currUptimeSuccess := int64(8)
|
|
currUptimeCount := int64(25)
|
|
|
|
{ // TestCreateNewAndWithStats
|
|
auditSuccessRatio := getRatio(currAuditSuccess, currAuditCount)
|
|
uptimeRatio := getRatio(currUptimeSuccess, currUptimeCount)
|
|
|
|
nodeStats := &overlay.NodeStats{
|
|
AuditSuccessRatio: auditSuccessRatio,
|
|
UptimeRatio: uptimeRatio,
|
|
AuditCount: currAuditCount,
|
|
AuditSuccessCount: currAuditSuccess,
|
|
UptimeCount: currUptimeCount,
|
|
UptimeSuccessCount: currUptimeSuccess,
|
|
}
|
|
|
|
err := cache.UpdateAddress(ctx, &pb.Node{Id: nodeID})
|
|
require.NoError(t, err)
|
|
|
|
stats, err := cache.CreateStats(ctx, nodeID, nodeStats)
|
|
require.NoError(t, err)
|
|
assert.EqualValues(t, auditSuccessRatio, stats.AuditSuccessRatio)
|
|
assert.EqualValues(t, uptimeRatio, stats.UptimeRatio)
|
|
|
|
node, err := cache.Get(ctx, nodeID)
|
|
require.NoError(t, err)
|
|
|
|
assert.EqualValues(t, currAuditCount, node.Reputation.AuditCount)
|
|
assert.EqualValues(t, currAuditSuccess, node.Reputation.AuditSuccessCount)
|
|
assert.EqualValues(t, auditSuccessRatio, node.Reputation.AuditSuccessRatio)
|
|
assert.EqualValues(t, currUptimeCount, node.Reputation.UptimeCount)
|
|
assert.EqualValues(t, currUptimeSuccess, node.Reputation.UptimeSuccessCount)
|
|
assert.EqualValues(t, uptimeRatio, node.Reputation.UptimeRatio)
|
|
}
|
|
|
|
{ // TestGetDoesNotExist
|
|
noNodeID := storj.NodeID{255, 255, 255, 255}
|
|
|
|
_, err := cache.Get(ctx, noNodeID)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
{ // TestKnownUnreliableOrOffline
|
|
for _, tt := range []struct {
|
|
nodeID storj.NodeID
|
|
auditSuccessCount int64
|
|
auditCount int64
|
|
auditSuccessRatio float64
|
|
uptimeSuccessCount int64
|
|
uptimeCount int64
|
|
uptimeRatio float64
|
|
}{
|
|
{storj.NodeID{1}, 20, 20, 1.0, 20, 20, 1.0}, // good ratios => good
|
|
{storj.NodeID{2}, 5, 20, 0.25, 20, 20, 1}, // bad audit success, good uptime => bad
|
|
{storj.NodeID{3}, 20, 20, 1.0, 5, 20, 0.25}, // good audit success, bad uptime => bad
|
|
{storj.NodeID{4}, 0, 0, 0.0, 20, 20, 1.0}, // "bad" audit success, no audits => now considered bad
|
|
{storj.NodeID{5}, 20, 20, 1.0, 0, 0, 0.25}, // "bad" uptime success, no checks => now considered bad
|
|
{storj.NodeID{6}, 0, 1, 0.0, 5, 5, .01}, // bad audit success exactly one audit => bad
|
|
{storj.NodeID{7}, 0, 20, 0.0, 20, 20, 1.0}, // impossible math, but good ratios => good
|
|
} {
|
|
nodeStats := &overlay.NodeStats{
|
|
AuditSuccessRatio: tt.auditSuccessRatio,
|
|
UptimeRatio: tt.uptimeRatio,
|
|
AuditCount: tt.auditCount,
|
|
AuditSuccessCount: tt.auditSuccessCount,
|
|
UptimeCount: tt.uptimeCount,
|
|
UptimeSuccessCount: tt.uptimeSuccessCount,
|
|
}
|
|
|
|
err := cache.UpdateAddress(ctx, &pb.Node{Id: tt.nodeID})
|
|
require.NoError(t, err)
|
|
|
|
_, err = cache.CreateStats(ctx, tt.nodeID, nodeStats)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
nodeIds := storj.NodeIDList{
|
|
storj.NodeID{1}, storj.NodeID{2},
|
|
storj.NodeID{3}, storj.NodeID{4},
|
|
storj.NodeID{5}, storj.NodeID{6},
|
|
}
|
|
criteria := &overlay.NodeCriteria{OnlineWindow: time.Hour}
|
|
|
|
invalid, err := cache.KnownUnreliableOrOffline(ctx, criteria, nodeIds)
|
|
require.NoError(t, err)
|
|
|
|
assert.Contains(t, invalid, storj.NodeID{2})
|
|
assert.Contains(t, invalid, storj.NodeID{3})
|
|
assert.Contains(t, invalid, storj.NodeID{4})
|
|
assert.Contains(t, invalid, storj.NodeID{5})
|
|
assert.Contains(t, invalid, storj.NodeID{6})
|
|
assert.Len(t, invalid, 5)
|
|
}
|
|
|
|
{ // TestUpdateOperator
|
|
nodeID := storj.NodeID{10}
|
|
err := cache.UpdateAddress(ctx, &pb.Node{Id: nodeID})
|
|
require.NoError(t, err)
|
|
|
|
update, err := cache.UpdateNodeInfo(ctx, nodeID, &pb.InfoResponse{
|
|
Operator: &pb.NodeOperator{
|
|
Wallet: "0x1111111111111111111111111111111111111111",
|
|
Email: "abc123@mail.test",
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, update)
|
|
|
|
found, err := cache.Get(ctx, nodeID)
|
|
assert.NotNil(t, found)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "0x1111111111111111111111111111111111111111", update.Operator.Wallet)
|
|
assert.Equal(t, "abc123@mail.test", update.Operator.Email)
|
|
|
|
updateEmail, err := cache.UpdateNodeInfo(ctx, nodeID, &pb.InfoResponse{
|
|
Operator: &pb.NodeOperator{
|
|
Wallet: update.Operator.Wallet,
|
|
Email: "def456@mail.test",
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, updateEmail)
|
|
assert.Equal(t, "0x1111111111111111111111111111111111111111", updateEmail.Operator.Wallet)
|
|
assert.Equal(t, "def456@mail.test", updateEmail.Operator.Email)
|
|
|
|
updateWallet, err := cache.UpdateNodeInfo(ctx, nodeID, &pb.InfoResponse{
|
|
Operator: &pb.NodeOperator{
|
|
Wallet: "0x2222222222222222222222222222222222222222",
|
|
Email: updateEmail.Operator.Email,
|
|
},
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, updateWallet)
|
|
assert.Equal(t, "0x2222222222222222222222222222222222222222", updateWallet.Operator.Wallet)
|
|
assert.Equal(t, "def456@mail.test", updateWallet.Operator.Email)
|
|
}
|
|
|
|
{ // TestUpdateExists
|
|
auditSuccessRatio := getRatio(currAuditSuccess, currAuditCount)
|
|
uptimeRatio := getRatio(currUptimeSuccess, currUptimeCount)
|
|
|
|
node, err := cache.Get(ctx, nodeID)
|
|
require.NoError(t, err)
|
|
|
|
assert.EqualValues(t, currAuditCount, node.Reputation.AuditCount)
|
|
assert.EqualValues(t, currAuditSuccess, node.Reputation.AuditSuccessCount)
|
|
assert.EqualValues(t, auditSuccessRatio, node.Reputation.AuditSuccessRatio)
|
|
assert.EqualValues(t, currUptimeCount, node.Reputation.UptimeCount)
|
|
assert.EqualValues(t, currUptimeSuccess, node.Reputation.UptimeSuccessCount)
|
|
assert.EqualValues(t, uptimeRatio, node.Reputation.UptimeRatio)
|
|
|
|
updateReq := &overlay.UpdateRequest{
|
|
NodeID: nodeID,
|
|
AuditSuccess: true,
|
|
IsUp: false,
|
|
}
|
|
stats, err := cache.UpdateStats(ctx, updateReq)
|
|
require.NoError(t, err)
|
|
|
|
currAuditSuccess++
|
|
currAuditCount++
|
|
currUptimeCount++
|
|
newAuditRatio := getRatio(currAuditSuccess, currAuditCount)
|
|
newUptimeRatio := getRatio(currUptimeSuccess, currUptimeCount)
|
|
|
|
assert.EqualValues(t, newAuditRatio, stats.AuditSuccessRatio)
|
|
assert.EqualValues(t, newUptimeRatio, stats.UptimeRatio)
|
|
}
|
|
|
|
{ // TestUpdateUptimeExists
|
|
auditSuccessRatio := getRatio(currAuditSuccess, currAuditCount)
|
|
uptimeRatio := getRatio(currUptimeSuccess, currUptimeCount)
|
|
|
|
node, err := cache.Get(ctx, nodeID)
|
|
require.NoError(t, err)
|
|
|
|
assert.EqualValues(t, currAuditCount, node.Reputation.AuditCount)
|
|
assert.EqualValues(t, currAuditSuccess, node.Reputation.AuditSuccessCount)
|
|
assert.EqualValues(t, auditSuccessRatio, node.Reputation.AuditSuccessRatio)
|
|
assert.EqualValues(t, currUptimeCount, node.Reputation.UptimeCount)
|
|
assert.EqualValues(t, currUptimeSuccess, node.Reputation.UptimeSuccessCount)
|
|
assert.EqualValues(t, uptimeRatio, node.Reputation.UptimeRatio)
|
|
|
|
stats, err := cache.UpdateUptime(ctx, nodeID, false)
|
|
require.NoError(t, err)
|
|
|
|
currUptimeCount++
|
|
newUptimeRatio := getRatio(currUptimeSuccess, currUptimeCount)
|
|
assert.EqualValues(t, auditSuccessRatio, stats.AuditSuccessRatio)
|
|
assert.EqualValues(t, currAuditCount, stats.AuditCount)
|
|
assert.EqualValues(t, newUptimeRatio, stats.UptimeRatio)
|
|
}
|
|
|
|
{ // TestUpdateStatsExists
|
|
auditSuccessRatio := getRatio(currAuditSuccess, currAuditCount)
|
|
uptimeRatio := getRatio(currUptimeSuccess, currUptimeCount)
|
|
|
|
node, err := cache.Get(ctx, nodeID)
|
|
require.NoError(t, err)
|
|
|
|
assert.EqualValues(t, currAuditCount, node.Reputation.AuditCount)
|
|
assert.EqualValues(t, currAuditSuccess, node.Reputation.AuditSuccessCount)
|
|
assert.EqualValues(t, auditSuccessRatio, node.Reputation.AuditSuccessRatio)
|
|
assert.EqualValues(t, currUptimeCount, node.Reputation.UptimeCount)
|
|
assert.EqualValues(t, currUptimeSuccess, node.Reputation.UptimeSuccessCount)
|
|
assert.EqualValues(t, uptimeRatio, node.Reputation.UptimeRatio)
|
|
|
|
stats, err := cache.UpdateStats(ctx, &overlay.UpdateRequest{
|
|
NodeID: nodeID,
|
|
IsUp: true,
|
|
AuditSuccess: false,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
currAuditCount++
|
|
newAuditRatio := getRatio(stats.AuditSuccessCount, stats.AuditCount)
|
|
assert.EqualValues(t, newAuditRatio, stats.AuditSuccessRatio)
|
|
assert.EqualValues(t, currAuditCount, stats.AuditCount)
|
|
newUptimeRatio := getRatio(stats.UptimeSuccessCount, stats.UptimeCount)
|
|
assert.EqualValues(t, newUptimeRatio, stats.UptimeRatio)
|
|
}
|
|
}
|