github.com/celestiaorg/celestia-node@v0.15.0-beta.1/nodebuilder/tests/da_test.go (about)

     1  //go:build da || integration
     2  
     3  package tests
     4  
     5  import (
     6  	"bytes"
     7  	"context"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/libp2p/go-libp2p/core/host"
    12  	"github.com/libp2p/go-libp2p/core/peer"
    13  	"github.com/stretchr/testify/require"
    14  
    15  	"github.com/celestiaorg/celestia-app/pkg/appconsts"
    16  
    17  	"github.com/celestiaorg/celestia-node/blob"
    18  	"github.com/celestiaorg/celestia-node/blob/blobtest"
    19  	"github.com/celestiaorg/celestia-node/nodebuilder/da"
    20  	"github.com/celestiaorg/celestia-node/nodebuilder/node"
    21  	"github.com/celestiaorg/celestia-node/nodebuilder/tests/swamp"
    22  	"github.com/celestiaorg/celestia-node/share"
    23  )
    24  
    25  func TestDaModule(t *testing.T) {
    26  	ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)
    27  	t.Cleanup(cancel)
    28  	sw := swamp.NewSwamp(t, swamp.WithBlockTime(time.Second))
    29  
    30  	namespace, err := share.NewBlobNamespaceV0([]byte("namespace"))
    31  	require.NoError(t, err)
    32  
    33  	appBlobs0, err := blobtest.GenerateV0Blobs([]int{8, 4}, true)
    34  	require.NoError(t, err)
    35  	appBlobs1, err := blobtest.GenerateV0Blobs([]int{4}, false)
    36  	require.NoError(t, err)
    37  	blobs := make([]*blob.Blob, 0, len(appBlobs0)+len(appBlobs1))
    38  	daBlobs := make([][]byte, 0, len(appBlobs0)+len(appBlobs1))
    39  
    40  	for _, b := range append(appBlobs0, appBlobs1...) {
    41  		blob, err := blob.NewBlob(b.ShareVersion, namespace, b.Data)
    42  		require.NoError(t, err)
    43  		blobs = append(blobs, blob)
    44  		daBlobs = append(daBlobs, blob.Data)
    45  	}
    46  
    47  	require.NoError(t, err)
    48  	bridge := sw.NewBridgeNode()
    49  	require.NoError(t, bridge.Start(ctx))
    50  
    51  	addrs, err := peer.AddrInfoToP2pAddrs(host.InfoFromHost(bridge.Host))
    52  	require.NoError(t, err)
    53  
    54  	fullCfg := sw.DefaultTestConfig(node.Full)
    55  	fullCfg.Header.TrustedPeers = append(fullCfg.Header.TrustedPeers, addrs[0].String())
    56  	fullNode := sw.NewNodeWithConfig(node.Full, fullCfg)
    57  	require.NoError(t, fullNode.Start(ctx))
    58  
    59  	addrsFull, err := peer.AddrInfoToP2pAddrs(host.InfoFromHost(fullNode.Host))
    60  	require.NoError(t, err)
    61  
    62  	lightCfg := sw.DefaultTestConfig(node.Light)
    63  	lightCfg.Header.TrustedPeers = append(lightCfg.Header.TrustedPeers, addrsFull[0].String())
    64  	lightNode := sw.NewNodeWithConfig(node.Light, lightCfg)
    65  	require.NoError(t, lightNode.Start(ctx))
    66  
    67  	fullClient := getAdminClient(ctx, fullNode, t)
    68  	lightClient := getAdminClient(ctx, lightNode, t)
    69  
    70  	ids, err := fullClient.DA.Submit(ctx, daBlobs, -1, namespace)
    71  	require.NoError(t, err)
    72  
    73  	var test = []struct {
    74  		name string
    75  		doFn func(t *testing.T)
    76  	}{
    77  		{
    78  			name: "MaxBlobSize",
    79  			doFn: func(t *testing.T) {
    80  				mbs, err := fullClient.DA.MaxBlobSize(ctx)
    81  				require.NoError(t, err)
    82  				require.Equal(t, mbs, uint64(appconsts.DefaultMaxBytes))
    83  			},
    84  		},
    85  		{
    86  			name: "GetProofs + Validate",
    87  			doFn: func(t *testing.T) {
    88  				t.Skip()
    89  				h, _ := da.SplitID(ids[0])
    90  				lightClient.Header.WaitForHeight(ctx, h)
    91  				proofs, err := lightClient.DA.GetProofs(ctx, ids, namespace)
    92  				require.NoError(t, err)
    93  				require.NotEmpty(t, proofs)
    94  				valid, err := fullClient.DA.Validate(ctx, ids, proofs, namespace)
    95  				require.NoError(t, err)
    96  				for _, v := range valid {
    97  					require.True(t, v)
    98  				}
    99  			},
   100  		},
   101  		{
   102  			name: "GetIDs",
   103  			doFn: func(t *testing.T) {
   104  				t.Skip()
   105  				height, _ := da.SplitID(ids[0])
   106  				ids2, err := fullClient.DA.GetIDs(ctx, height, namespace)
   107  				require.NoError(t, err)
   108  				require.EqualValues(t, ids, ids2)
   109  			},
   110  		},
   111  		{
   112  			name: "Get",
   113  			doFn: func(t *testing.T) {
   114  				h, _ := da.SplitID(ids[0])
   115  				lightClient.Header.WaitForHeight(ctx, h)
   116  				fetched, err := lightClient.DA.Get(ctx, ids, namespace)
   117  				require.NoError(t, err)
   118  				require.Len(t, fetched, len(ids))
   119  				for i := range fetched {
   120  					require.True(t, bytes.Equal(fetched[i], daBlobs[i]))
   121  				}
   122  			},
   123  		},
   124  		{
   125  			name: "Commit",
   126  			doFn: func(t *testing.T) {
   127  				t.Skip()
   128  				fetched, err := fullClient.DA.Commit(ctx, ids, namespace)
   129  				require.NoError(t, err)
   130  				require.Len(t, fetched, len(ids))
   131  				for i := range fetched {
   132  					_, commitment := da.SplitID(ids[i])
   133  					require.EqualValues(t, fetched[i], commitment)
   134  				}
   135  			},
   136  		},
   137  	}
   138  
   139  	for _, tt := range test {
   140  		tt := tt
   141  		t.Run(tt.name, func(t *testing.T) {
   142  			tt.doFn(t)
   143  		})
   144  	}
   145  }