github.com/qri-io/qri@v0.10.1-0.20220104210721-c771715036cb/logbook/logsync/p2p_test.go (about)

     1  package logsync
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	libp2p "github.com/libp2p/go-libp2p"
     8  	crypto "github.com/libp2p/go-libp2p-core/crypto"
     9  	host "github.com/libp2p/go-libp2p-core/host"
    10  	peer "github.com/libp2p/go-libp2p-core/peer"
    11  	pstoremem "github.com/libp2p/go-libp2p-peerstore/pstoremem"
    12  	ma "github.com/multiformats/go-multiaddr"
    13  )
    14  
    15  func TestP2PLogsync(t *testing.T) {
    16  	t.Skip("TODO(dustmop): validating profileID in logbook data causes this to hang")
    17  
    18  	tr, cleanup := newTestRunner(t)
    19  	defer cleanup()
    20  
    21  	aHost := p2pHost(tr.Ctx, tr.APrivKey, t)
    22  	bHost := p2pHost(tr.Ctx, tr.BPrivKey, t)
    23  
    24  	lsA := New(tr.A, func(o *Options) {
    25  		o.Libp2pHost = aHost
    26  	})
    27  
    28  	lsB := New(tr.B, func(o *Options) {
    29  		o.Libp2pHost = bHost
    30  	})
    31  
    32  	// connect a & b
    33  	if err := aHost.Connect(tr.Ctx, peer.AddrInfo{ID: bHost.ID(), Addrs: bHost.Addrs()}); err != nil {
    34  		t.Fatal(err)
    35  	}
    36  
    37  	// make some logs on A
    38  	worldBankRef, err := writeWorldBankLogs(tr.Ctx, tr.A)
    39  	if err != nil {
    40  		t.Fatal(err)
    41  	}
    42  
    43  	// pull logs to B from A
    44  	aID := tr.A.Owner().ID.Encode()
    45  
    46  	pull, err := lsB.NewPull(worldBankRef, aID)
    47  	if err != nil {
    48  		t.Error(err)
    49  	}
    50  	pull.Merge = true
    51  
    52  	if _, err := pull.Do(tr.Ctx); err != nil {
    53  		t.Error(err)
    54  	}
    55  
    56  	items, err := tr.B.Items(tr.Ctx, worldBankRef, 0, 10, "")
    57  	if err != nil {
    58  		t.Errorf("expected no error fetching dslog items after pull. got: %s", err)
    59  	}
    60  	if len(items) == 0 {
    61  		t.Errorf("expected some length of logs. got: %d", len(items))
    62  	}
    63  
    64  	// add moar logs to A
    65  	nasdaqRef, err := writeNasdaqLogs(tr.Ctx, tr.A)
    66  	if err != nil {
    67  		t.Fatal(err)
    68  	}
    69  
    70  	// push logs from A to B
    71  	bID := tr.B.Owner().ID.Encode()
    72  
    73  	push, err := lsA.NewPush(nasdaqRef, bID)
    74  	if err != nil {
    75  		t.Fatal(err)
    76  	}
    77  
    78  	if err := push.Do(tr.Ctx); err != nil {
    79  		t.Fatal(err)
    80  	}
    81  
    82  	items, err = tr.B.Items(tr.Ctx, nasdaqRef, 0, 10, "")
    83  	if err != nil {
    84  		t.Errorf("expected no error fetching dslog items after pull. got: %s", err)
    85  	}
    86  	if len(items) == 0 {
    87  		t.Errorf("expected some length of logs. got: %d", len(items))
    88  	}
    89  
    90  	// A request B removes nasdaq
    91  	if err := lsA.DoRemove(tr.Ctx, nasdaqRef, bID); err != nil {
    92  		t.Errorf("unexpected error doing remove request: %s", err)
    93  	}
    94  	if _, err = tr.B.Items(tr.Ctx, nasdaqRef, 0, 10, ""); err == nil {
    95  		t.Errorf("expected error fetching dslog items. got nil")
    96  	}
    97  }
    98  
    99  // makeBasicHost creates a LibP2P host from a NodeCfg
   100  func p2pHost(ctx context.Context, pk crypto.PrivKey, t *testing.T) host.Host {
   101  	pid, err := peer.IDFromPrivateKey(pk)
   102  	if err != nil {
   103  		t.Fatal(err)
   104  	}
   105  
   106  	ps := pstoremem.NewPeerstore()
   107  	ps.AddPrivKey(pid, pk)
   108  	ps.AddPubKey(pid, pk.GetPublic())
   109  
   110  	addr, _ := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/0")
   111  
   112  	opts := []libp2p.Option{
   113  		libp2p.Identity(pk),
   114  		libp2p.ListenAddrs(addr),
   115  		libp2p.Peerstore(ps),
   116  	}
   117  
   118  	host, err := libp2p.New(ctx, opts...)
   119  	if err != nil {
   120  		t.Fatal(err)
   121  	}
   122  	return host
   123  }