github.com/decred/dcrlnd@v0.7.6/channeldb/nodes_test.go (about)

     1  package channeldb
     2  
     3  import (
     4  	"bytes"
     5  	"net"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/decred/dcrd/wire"
    10  )
    11  
    12  func TestLinkNodeEncodeDecode(t *testing.T) {
    13  	t.Parallel()
    14  
    15  	fullDB, cleanUp, err := MakeTestDB()
    16  	if err != nil {
    17  		t.Fatalf("unable to make test database: %v", err)
    18  	}
    19  	defer cleanUp()
    20  
    21  	cdb := fullDB.ChannelStateDB()
    22  
    23  	// First we'll create some initial data to use for populating our test
    24  	// LinkNode instances.
    25  	_, pub1 := privKeyFromBytes(key[:])
    26  	_, pub2 := privKeyFromBytes(rev[:])
    27  	addr1, err := net.ResolveTCPAddr("tcp", "10.0.0.1:9000")
    28  	if err != nil {
    29  		t.Fatalf("unable to create test addr: %v", err)
    30  	}
    31  	addr2, err := net.ResolveTCPAddr("tcp", "10.0.0.2:9000")
    32  	if err != nil {
    33  		t.Fatalf("unable to create test addr: %v", err)
    34  	}
    35  
    36  	// Create two fresh link node instances with the above dummy data, then
    37  	// fully sync both instances to disk.
    38  	node1 := NewLinkNode(cdb.linkNodeDB, wire.MainNet, pub1, addr1)
    39  	node2 := NewLinkNode(cdb.linkNodeDB, wire.TestNet3, pub2, addr2)
    40  	if err := node1.Sync(); err != nil {
    41  		t.Fatalf("unable to sync node: %v", err)
    42  	}
    43  	if err := node2.Sync(); err != nil {
    44  		t.Fatalf("unable to sync node: %v", err)
    45  	}
    46  
    47  	// Fetch all current link nodes from the database, they should exactly
    48  	// match the two created above.
    49  	originalNodes := []*LinkNode{node2, node1}
    50  	linkNodes, err := cdb.linkNodeDB.FetchAllLinkNodes()
    51  	if err != nil {
    52  		t.Fatalf("unable to fetch nodes: %v", err)
    53  	}
    54  	for i, node := range linkNodes {
    55  		if originalNodes[i].Network != node.Network {
    56  			t.Fatalf("node networks don't match: expected %v, got %v",
    57  				originalNodes[i].Network, node.Network)
    58  		}
    59  
    60  		originalPubkey := originalNodes[i].IdentityPub.SerializeCompressed()
    61  		dbPubkey := node.IdentityPub.SerializeCompressed()
    62  		if !bytes.Equal(originalPubkey, dbPubkey) {
    63  			t.Fatalf("node pubkeys don't match: expected %x, got %x",
    64  				originalPubkey, dbPubkey)
    65  		}
    66  		if originalNodes[i].LastSeen.Unix() != node.LastSeen.Unix() {
    67  			t.Fatalf("last seen timestamps don't match: expected %v got %v",
    68  				originalNodes[i].LastSeen.Unix(), node.LastSeen.Unix())
    69  		}
    70  		if originalNodes[i].Addresses[0].String() != node.Addresses[0].String() {
    71  			t.Fatalf("addresses don't match: expected %v, got %v",
    72  				originalNodes[i].Addresses, node.Addresses)
    73  		}
    74  	}
    75  
    76  	// Next, we'll exercise the methods to append additional IP
    77  	// addresses, and also to update the last seen time.
    78  	if err := node1.UpdateLastSeen(time.Now()); err != nil {
    79  		t.Fatalf("unable to update last seen: %v", err)
    80  	}
    81  	if err := node1.AddAddress(addr2); err != nil {
    82  		t.Fatalf("unable to update addr: %v", err)
    83  	}
    84  
    85  	// Fetch the same node from the database according to its public key.
    86  	node1DB, err := cdb.linkNodeDB.FetchLinkNode(pub1)
    87  	if err != nil {
    88  		t.Fatalf("unable to find node: %v", err)
    89  	}
    90  
    91  	// Both the last seen timestamp and the list of reachable addresses for
    92  	// the node should be updated.
    93  	if node1DB.LastSeen.Unix() != node1.LastSeen.Unix() {
    94  		t.Fatalf("last seen timestamps don't match: expected %v got %v",
    95  			node1.LastSeen.Unix(), node1DB.LastSeen.Unix())
    96  	}
    97  	if len(node1DB.Addresses) != 2 {
    98  		t.Fatalf("wrong length for node1 addresses: expected %v, got %v",
    99  			2, len(node1DB.Addresses))
   100  	}
   101  	if node1DB.Addresses[0].String() != addr1.String() {
   102  		t.Fatalf("wrong address for node: expected %v, got %v",
   103  			addr1.String(), node1DB.Addresses[0].String())
   104  	}
   105  	if node1DB.Addresses[1].String() != addr2.String() {
   106  		t.Fatalf("wrong address for node: expected %v, got %v",
   107  			addr2.String(), node1DB.Addresses[1].String())
   108  	}
   109  }
   110  
   111  func TestDeleteLinkNode(t *testing.T) {
   112  	t.Parallel()
   113  
   114  	fullDB, cleanUp, err := MakeTestDB()
   115  	if err != nil {
   116  		t.Fatalf("unable to make test database: %v", err)
   117  	}
   118  	defer cleanUp()
   119  
   120  	cdb := fullDB.ChannelStateDB()
   121  
   122  	_, pubKey := privKeyFromBytes(key[:])
   123  	addr := &net.TCPAddr{
   124  		IP:   net.ParseIP("127.0.0.1"),
   125  		Port: 1337,
   126  	}
   127  	linkNode := NewLinkNode(cdb.linkNodeDB, wire.TestNet3, pubKey, addr)
   128  	if err := linkNode.Sync(); err != nil {
   129  		t.Fatalf("unable to write link node to db: %v", err)
   130  	}
   131  
   132  	if _, err := cdb.linkNodeDB.FetchLinkNode(pubKey); err != nil {
   133  		t.Fatalf("unable to find link node: %v", err)
   134  	}
   135  
   136  	if err := cdb.linkNodeDB.DeleteLinkNode(pubKey); err != nil {
   137  		t.Fatalf("unable to delete link node from db: %v", err)
   138  	}
   139  
   140  	if _, err := cdb.linkNodeDB.FetchLinkNode(pubKey); err == nil {
   141  		t.Fatal("should not have found link node in db, but did")
   142  	}
   143  }