gitlab.com/SkynetLabs/skyd@v1.6.9/skymodules/renter/hostdb/scan_test.go

package hostdb

import (
	"errors"
	"testing"
	"time"

	"gitlab.com/SkynetLabs/skyd/siatest/dependencies"
	"gitlab.com/SkynetLabs/skyd/skymodules"
	"go.sia.tech/siad/types"
)

// TestUpdateEntry checks that the various components of updateEntry are
// working correctly.
func TestUpdateEntry(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}

	// Create a multi dependency that disables the scan loop in the HostDB and
	// avoids a critical when we encounter a HostDB entry with an unsorted scan
	// history.
	dep1 := &dependencies.DependencyDisableScanLoopDeps{}
	dep2 := &dependencies.DependencyDisableCriticalOnUnsortedHistory{}
	hdbt, err := newHDBTesterDeps(t.Name(), dependencies.NewMultiDependency(dep1, dep2))
	if err != nil {
		t.Fatal(err)
	}

	// Test 1: try calling updateEntry with a blank host. Result should be a
	// host with len 2 scan history.
	someErr := errors.New("testing err")
	entry1 := skymodules.HostDBEntry{
		PublicKey: types.SiaPublicKey{
			Key: []byte{1},
		},
	}
	entry2 := skymodules.HostDBEntry{
		PublicKey: types.SiaPublicKey{
			Key: []byte{2},
		},
	}
	entry3 := skymodules.HostDBEntry{
		PublicKey: types.SiaPublicKey{
			Key: []byte{3},
		},
	}
	entry4 := skymodules.HostDBEntry{
		PublicKey: types.SiaPublicKey{
			Key: []byte{4},
		},
	}

	// Try inserting the first entry. Result in the host tree should be a host
	// with a scan history length of two.
	hdbt.hdb.updateEntry(entry1, nil)
	updatedEntry, exists := hdbt.hdb.staticHostTree.Select(entry1.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	if len(updatedEntry.ScanHistory) != 2 {
		t.Fatal("new entry was not given two scanning history entries")
	}
	if !updatedEntry.ScanHistory[0].Timestamp.Before(updatedEntry.ScanHistory[1].Timestamp) {
		t.Error("new entry was not provided with a sorted scanning history")
	}
	if !updatedEntry.ScanHistory[0].Success || !updatedEntry.ScanHistory[1].Success {
		t.Error("new entry was not given success values despite a successful scan")
	}

	// Try inserting the second entry, but with an error. Results should largely
	// be the same.
	hdbt.hdb.updateEntry(entry2, someErr)
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry2.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	if len(updatedEntry.ScanHistory) != 2 {
		t.Fatal("new entry was not given two scanning history entries")
	}
	if !updatedEntry.ScanHistory[0].Timestamp.Before(updatedEntry.ScanHistory[1].Timestamp) {
		t.Error("new entry was not provided with a sorted scanning history")
	}
	if updatedEntry.ScanHistory[0].Success || updatedEntry.ScanHistory[1].Success {
		t.Error("new entry was not given success values despite a successful scan")
	}

	// Try inserting the entry twice rapidly, nothing should change in the scan
	// history length because it won't accept such a short turnaround.
	hdbt.hdb.updateEntry(entry1, nil)
	hdbt.hdb.updateEntry(entry1, nil)
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry1.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	if len(updatedEntry.ScanHistory) != 2 {
		t.Fatal("new updates should have been ignored", len(updatedEntry.ScanHistory))
	}

	// Insert the first entry twice more, with no error. There should be 4
	// entries, and the timestamps should be strictly increasing. Sleep for a
	// bit between each update, because the hostdb during testing will not count
	// scans if they are added too close together.
	time.Sleep(3 * scanTimeElapsedRequirement)
	hdbt.hdb.updateEntry(entry1, nil)
	time.Sleep(3 * scanTimeElapsedRequirement)
	hdbt.hdb.updateEntry(entry1, nil)
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry1.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	if len(updatedEntry.ScanHistory) != 4 {
		t.Fatal("new entry was not given two scanning history entries", len(updatedEntry.ScanHistory))
	}
	if !updatedEntry.ScanHistory[1].Timestamp.Before(updatedEntry.ScanHistory[2].Timestamp) {
		t.Error("new entry was not provided with a sorted scanning history")
	}
	if !updatedEntry.ScanHistory[2].Timestamp.Before(updatedEntry.ScanHistory[3].Timestamp) {
		t.Error("new entry was not provided with a sorted scanning history")
	}
	if !updatedEntry.ScanHistory[2].Success || !updatedEntry.ScanHistory[3].Success {
		t.Error("new entries did not get added with successful timestamps")
	}

	// Add a non-successful scan and verify that it is registered properly.
	time.Sleep(3 * scanTimeElapsedRequirement)
	hdbt.hdb.updateEntry(entry1, someErr)
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry1.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	if len(updatedEntry.ScanHistory) != 5 {
		t.Fatal("new entry was not given two scanning history entries")
	}
	if !updatedEntry.ScanHistory[3].Success || updatedEntry.ScanHistory[4].Success {
		t.Error("new entries did not get added with successful timestamps")
	}

	// Prefix an invalid entry to have a scan from more than maxHostDowntime
	// days ago. At less than minScans total, the host should not be deleted
	// upon update.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry2.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	updatedEntry.ScanHistory = append([]skymodules.HostDBScan{{}}, updatedEntry.ScanHistory...)
	err = hdbt.hdb.staticHostTree.Modify(updatedEntry)
	if err != nil {
		t.Fatal(err)
	}
	// Entry should still exist.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry2.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	// Add enough entries to get to minScans total length. When that length is
	// reached, the entry should be deleted.
	for i := len(updatedEntry.ScanHistory); i < minScans; i++ {
		time.Sleep(3 * scanTimeElapsedRequirement)
		hdbt.hdb.updateEntry(entry2, someErr)
	}
	// The entry should no longer exist in the hostdb, wiped for being offline.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry2.PublicKey)
	if exists {
		t.Fatal("entry should have been purged for being offline for too long")
	}

	// Trigger compression on entry1 by adding a past scan and then adding
	// unsuccessful scans until compression happens.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry1.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	updatedEntry.ScanHistory = append([]skymodules.HostDBScan{{Timestamp: time.Now().Add(maxHostDowntime * -1).Add(time.Hour * -1)}}, updatedEntry.ScanHistory...)
	err = hdbt.hdb.staticHostTree.Modify(updatedEntry)
	if err != nil {
		t.Fatal(err)
	}
	for i := len(updatedEntry.ScanHistory); i <= minScans; i++ {
		time.Sleep(3 * scanTimeElapsedRequirement)
		hdbt.hdb.updateEntry(entry1, someErr)
	}
	// The result should be compression, and not the entry getting deleted.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry1.PublicKey)
	if !exists {
		t.Fatal("entry should not have been purged for being offline for too long")
	}
	if len(updatedEntry.ScanHistory) != minScans {
		t.Error("expecting a different number of scans", len(updatedEntry.ScanHistory))
	}
	if updatedEntry.HistoricDowntime == 0 {
		t.Error("host reporting historic downtime?")
	}
	if updatedEntry.HistoricUptime != 0 {
		t.Error("host not reporting historic uptime?")
	}

	// Repeat triggering compression, but with uptime this time.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry1.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	updatedEntry.ScanHistory = append([]skymodules.HostDBScan{{Success: true, Timestamp: time.Now().Add(time.Hour * 24 * (maxHostDownTimeInDays + 1) * -1)}}, updatedEntry.ScanHistory...)
	err = hdbt.hdb.staticHostTree.Modify(updatedEntry)
	if err != nil {
		t.Fatal(err)
	}
	time.Sleep(3 * scanTimeElapsedRequirement)
	hdbt.hdb.updateEntry(entry1, someErr)

	// The result should be compression, and not the entry getting deleted.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry1.PublicKey)
	if !exists {
		t.Fatal("entry should not have been purged for being offline for too long")
	}
	if len(updatedEntry.ScanHistory) != minScans+1 {
		t.Error("expecting a different number of scans")
	}
	if updatedEntry.HistoricUptime == 0 {
		t.Error("host not reporting historic uptime?")
	}

	// The initial scan should be ordered even if the entry's 'FirstSeen'
	// property is greater than the HostDB blockheight
	hdbt.hdb.blockHeight = types.BlockHeight(10)
	entry3.FirstSeen = types.BlockHeight(20)
	hdbt.hdb.updateEntry(entry3, nil)

	// Fetch the updated entry and assert the scan history is in order
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry3.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	if len(updatedEntry.ScanHistory) != 2 {
		t.Error("expecting a different number of scans")
	}
	if !updatedEntry.ScanHistory[0].Timestamp.Before(updatedEntry.ScanHistory[1].Timestamp) {
		t.Error("expecting scan entries to be chronologically ordered")
	}

	// Entries with a corrupted scan history should be fixed
	entry4.ScanHistory = skymodules.HostDBScans{
		{Timestamp: time.Now(), Success: true},
		{Timestamp: time.Now().Add(scanTimeElapsedRequirement * -3), Success: true},
		{Timestamp: time.Now().Add(scanTimeElapsedRequirement * -2), Success: true},
	}
	err = hdbt.hdb.insert(entry4)
	if err != nil {
		t.Fatal("Entry did not get inserted into the host db", err)
	}
	hdbt.hdb.updateEntry(entry4, nil)

	// Assert the scan history got fixed and a new entry was added
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry4.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	if len(updatedEntry.ScanHistory) != 4 {
		t.Error("expecting a different number of scans")
	}
	if !updatedEntry.ScanHistory[0].Timestamp.Before(updatedEntry.ScanHistory[1].Timestamp) {
		t.Error("expecting scan entries to be chronologically ordered")
	}
}

// TestFeeChangeSignificant is a unit test for the feeChangeSignificant
// function.
func TestFeeChangeSignificant(t *testing.T) {
	// If the difference is exactly txnFeesUpdateRatio it is significant.
	n1 := uint64(100)
	n2 := uint64(100 * (1 + txnFeesUpdateRatio))
	s := feeChangeSignificant(types.NewCurrency64(n1), types.NewCurrency64(n2))
	if !s {
		t.Fatalf("should be significant but wasn't")
	}
	n1 = uint64(100)
	n2 = uint64(100 * (1 - txnFeesUpdateRatio))
	s = feeChangeSignificant(types.NewCurrency64(n1), types.NewCurrency64(n2))
	if !s {
		t.Fatalf("should be significant but wasn't")
	}
	// If the difference is bigger than txnFeesUpdateRatio it is significant.
	n1 = uint64(100)
	n2 = uint64(100*(1+txnFeesUpdateRatio) + 1)
	s = feeChangeSignificant(types.NewCurrency64(n1), types.NewCurrency64(n2))
	if !s {
		t.Fatalf("should be significant but wasn't")
	}
	n1 = uint64(100)
	n2 = uint64(100*(1-txnFeesUpdateRatio) - 1)
	s = feeChangeSignificant(types.NewCurrency64(n1), types.NewCurrency64(n2))
	if !s {
		t.Fatalf("should be significant but wasn't")
	}
	// If the difference is a bit less then it shouldn't be significant.
	n1 = uint64(100)
	n2 = uint64(100*(1+txnFeesUpdateRatio) - 1)
	s = feeChangeSignificant(types.NewCurrency64(n1), types.NewCurrency64(n2))
	if s {
		t.Fatalf("shouldn't be significant but was")
	}
	n1 = uint64(100)
	n2 = uint64(100*(1-txnFeesUpdateRatio) + 1)
	s = feeChangeSignificant(types.NewCurrency64(n1), types.NewCurrency64(n2))
	if s {
		t.Fatalf("shouldn't be significant but was")
	}
}

// TestUpdateEntryWithKnown host checks that a host from a knownContract (i.e. a
// host we have a contract with currently) is never deleted from the host tree.
func TestUpdateEntryWithKnownHost(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	hdbt, err := newHDBTesterDeps(t.Name(), &dependencies.DependencyDisableScanLoopDeps{})
	if err != nil {
		t.Fatal(err)
	}

	entry := skymodules.HostDBEntry{
		PublicKey: types.SiaPublicKey{
			Key: []byte{1},
		},
	}
	// we need an err in updateEntry to make all interactions unsuccessful.
	someErr := errors.New("testing err")

	// Add the host from that entry to the knownContracts map.
	hdbt.hdb.mu.Lock()
	hdbt.hdb.knownContracts[entry.PublicKey.String()] = contractInfo{HostPublicKey: entry.PublicKey}
	hdbt.hdb.mu.Unlock()

	time.Sleep(3 * scanTimeElapsedRequirement)
	hdbt.hdb.updateEntry(entry, someErr)
	updatedEntry, exists := hdbt.hdb.staticHostTree.Select(entry.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}
	if len(updatedEntry.ScanHistory) != 2 {
		t.Fatal("new entry was not given two scanning history entries")
	}

	// Prefix an invalid entry to have a scan from more than maxHostDowntime
	// days ago. At less than minScans total, the host should not be deleted
	// upon update.
	updatedEntry.ScanHistory = append([]skymodules.HostDBScan{{}}, updatedEntry.ScanHistory...)
	err = hdbt.hdb.staticHostTree.Modify(updatedEntry)
	if err != nil {
		t.Fatal(err)
	}
	// Entry should still exist.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry.PublicKey)
	if !exists {
		t.Fatal("Entry did not get inserted into the host tree")
	}

	// Add enough entries to get to minScans total length.
	for i := len(updatedEntry.ScanHistory); i < minScans; i++ {
		time.Sleep(3 * scanTimeElapsedRequirement)
		hdbt.hdb.updateEntry(entry, someErr)
	}
	// The entry should **still** exist in the hostdb, despite being offline.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry.PublicKey)
	if !exists {
		t.Fatal("entry should not have been purged for being offline for too long")
	}

	// Remove the host from the hostContracts map and update with the same entry. It should
	// now be deleted.
	hdbt.hdb.mu.Lock()
	delete(hdbt.hdb.knownContracts, updatedEntry.PublicKey.String())
	hdbt.hdb.mu.Unlock()
	time.Sleep(3 * scanTimeElapsedRequirement)
	hdbt.hdb.updateEntry(entry, someErr)

	// Entry should not exist.
	updatedEntry, exists = hdbt.hdb.staticHostTree.Select(entry.PublicKey)
	if exists {
		t.Fatal("Entry did not get removed from the host tree")
	}
}

// Regression test to make sure managedWaitForScans shuts down at some point if
// the scanList has elements in it.
func TestWaitForScansShutdown(t *testing.T) {
	hdb := &HostDB{
		scanList: []skymodules.HostDBEntry{{}},
	}
	go func() {
		if err := hdb.tg.Stop(); err != nil {
			t.Error(err)
		}
	}()
	hdb.managedWaitForScans()
}

// TestCompatv164SortEntryScans is a unit test that asserts the entry scans are
// sorted properly.
func TestCompatv164SortEntryScans(t *testing.T) {
	t.Parallel()

	// isSorted returns whether the given scans are sorted
	isSorted := func(scans []skymodules.HostDBScan) bool {
		if len(scans) == 0 {
			return true
		}
		prev := scans[0].Timestamp
		for _, scan := range scans[1:] {
			if !scan.Timestamp.After(prev) {
				return false
			}
			prev = scan.Timestamp
		}
		return true
	}

	// base case
	entry := DefaultHostDBEntry
	entry.ScanHistory = skymodules.HostDBScans{
		{Timestamp: time.Now().Add(time.Hour * -100), Success: true},
		{Timestamp: time.Now().Add(time.Hour * -80), Success: true},
		{Timestamp: time.Now().Add(time.Hour * -60), Success: true},
	}
	updated := compatv164SortEntryScans(&entry)
	if updated {
		t.Fatal("unexpected")
	}

	// assert they're properly sorted
	if !isSorted(entry.ScanHistory) {
		t.Fatalf("unsorted %+v", entry.ScanHistory)
	}

	// unsorted case basic
	entry = DefaultHostDBEntry
	entry.ScanHistory = skymodules.HostDBScans{
		{Timestamp: time.Now().Add(time.Hour), Success: true},
		{Timestamp: time.Now().Add(time.Hour * -80), Success: true},
		{Timestamp: time.Now().Add(time.Hour * -60), Success: true},
	}
	updated = compatv164SortEntryScans(&entry)
	if !updated {
		t.Fatal("unexpected")
	}

	// assert they're properly sorted
	if !isSorted(entry.ScanHistory) {
		t.Fatalf("unsorted %+v", entry.ScanHistory)
	}

	// unsorted case all future
	entry = DefaultHostDBEntry
	entry.ScanHistory = skymodules.HostDBScans{
		{Timestamp: time.Now().Add(time.Hour), Success: true},
		{Timestamp: time.Now().Add(time.Hour * 2), Success: true},
		{Timestamp: time.Now().Add(time.Hour * 3), Success: true},
	}
	updated = compatv164SortEntryScans(&entry)
	if !updated {
		t.Fatal("unexpected")
	}

	// assert they're properly sorted
	if !isSorted(entry.ScanHistory) {
		t.Fatalf("unsorted %+v", entry.ScanHistory)
	}

	// unsorted case some future
	entry = DefaultHostDBEntry
	entry.ScanHistory = skymodules.HostDBScans{
		{Timestamp: time.Now().Add(time.Hour), Success: true},
		{Timestamp: time.Now().Add(time.Hour * 2), Success: true},
		{Timestamp: time.Now().Add(time.Hour * -80), Success: true},
		{Timestamp: time.Now().Add(time.Hour * -60), Success: true},
	}
	updated = compatv164SortEntryScans(&entry)
	if !updated {
		t.Fatal("unexpected")
	}

	// assert they're properly sorted
	if !isSorted(entry.ScanHistory) {
		t.Fatalf("unsorted %+v", entry.ScanHistory)
	}

	// unsorted case some future
	entry = DefaultHostDBEntry
	entry.ScanHistory = skymodules.HostDBScans{
		{Timestamp: time.Now().Add(time.Hour * -100), Success: true},
		{Timestamp: time.Now().Add(time.Hour * -80), Success: true},
		{Timestamp: time.Now().Add(time.Hour), Success: true},
		{Timestamp: time.Now().Add(time.Hour * -60), Success: true},
		{Timestamp: time.Now().Add(time.Hour), Success: true},
		{Timestamp: time.Now().Add(time.Hour * -40), Success: true},
	}
	updated = compatv164SortEntryScans(&entry)
	if !updated {
		t.Fatal("unexpected")
	}

	// assert they're properly sorted
	if !isSorted(entry.ScanHistory) {
		for _, scan := range entry.ScanHistory {
			t.Log(scan)
		}
		t.Fatal("unsorted")
	}
}