13589551993

Committed 28 Feb 2025 01:52PM UTC coverage: 58.841% (+0.007%) from 58.834%

Build # 13589551993

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9566 from yyforyongyu/improve-itest

lntest+itest: change the method signature of `AssertPaymentStatus`

Run Details

0 of 6 new or added lines in 2 files covered. (0.0%)

55 existing lines in 16 files now uncovered.

136440 of 231880 relevant lines covered (58.84%)

19280.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/itest/lnd_experimental_endorsement.go

package itest

import (
        "math"

        "github.com/btcsuite/btcd/btcutil"
        "github.com/lightningnetwork/lnd/lnrpc"
        "github.com/lightningnetwork/lnd/lnrpc/routerrpc"
        "github.com/lightningnetwork/lnd/lntest"
        "github.com/lightningnetwork/lnd/lntest/node"
        "github.com/lightningnetwork/lnd/lntest/rpc"
        "github.com/lightningnetwork/lnd/lntest/wait"
        "github.com/lightningnetwork/lnd/lntypes"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/stretchr/testify/require"
)

// testExperimentalEndorsement tests setting of positive and negative
// experimental endorsement signals.
func testExperimentalEndorsement(ht *lntest.HarnessTest) {
        testEndorsement(ht, true)
        testEndorsement(ht, false)
}

// testEndorsement sets up a 5 hop network and tests propagation of
// experimental endorsement signals.
func testEndorsement(ht *lntest.HarnessTest, aliceEndorse bool) {
        cfg := node.CfgAnchor
        carolCfg := append(
                []string{"--protocol.no-experimental-endorsement"}, cfg...,
        )
        cfgs := [][]string{cfg, cfg, carolCfg, cfg, cfg}

        const chanAmt = btcutil.Amount(300000)
        p := lntest.OpenChannelParams{Amt: chanAmt}

        _, nodes := ht.CreateSimpleNetwork(cfgs, p)
        alice, bob, carol, dave, eve := nodes[0], nodes[1], nodes[2], nodes[3],
                nodes[4]

        bobIntercept, cancelBob := bob.RPC.HtlcInterceptor()
        defer cancelBob()

        carolIntercept, cancelCarol := carol.RPC.HtlcInterceptor()
        defer cancelCarol()

        daveIntercept, cancelDave := dave.RPC.HtlcInterceptor()
        defer cancelDave()

        req := &lnrpc.Invoice{ValueMsat: 1000}
        addResponse := eve.RPC.AddInvoice(req)
        invoice := eve.RPC.LookupInvoice(addResponse.RHash)

        sendReq := &routerrpc.SendPaymentRequest{
                PaymentRequest: invoice.PaymentRequest,
                TimeoutSeconds: int32(wait.PaymentTimeout.Seconds()),
                FeeLimitMsat:   math.MaxInt64,
        }

        expectedValue := []byte{lnwire.ExperimentalUnendorsed}
        if aliceEndorse {
                expectedValue = []byte{lnwire.ExperimentalEndorsed}
                t := uint64(lnwire.ExperimentalEndorsementType)
                sendReq.FirstHopCustomRecords = map[uint64][]byte{
                        t: expectedValue,
                }
        }

        _ = alice.RPC.SendPayment(sendReq)

        // Validate that our signal (positive or zero) propagates until carol
        // and then is dropped because she has disabled the feature.
        validateEndorsedAndResume(ht, bobIntercept, true, expectedValue)
        validateEndorsedAndResume(ht, carolIntercept, true, expectedValue)
        validateEndorsedAndResume(ht, daveIntercept, false, nil)

        var preimage lntypes.Preimage
        copy(preimage[:], invoice.RPreimage)
        ht.AssertPaymentStatus(alice, preimage.Hash(), lnrpc.Payment_SUCCEEDED)
}

func validateEndorsedAndResume(ht *lntest.HarnessTest,
        interceptor rpc.InterceptorClient, hasEndorsement bool,
        expectedValue []byte) {

        packet := ht.ReceiveHtlcInterceptor(interceptor)

        var expectedRecords map[uint64][]byte
        if hasEndorsement {
                u64Type := uint64(lnwire.ExperimentalEndorsementType)
                expectedRecords = map[uint64][]byte{
                        u64Type: expectedValue,
                }
        }
        require.Equal(ht, expectedRecords, packet.InWireCustomRecords)

        err := interceptor.Send(&routerrpc.ForwardHtlcInterceptResponse{
                IncomingCircuitKey: packet.IncomingCircuitKey,
                Action:             routerrpc.ResolveHoldForwardAction_RESUME,
        })
        require.NoError(ht, err)
}

1	package itest
2
3	import (
4	"math"
5
6	"github.com/btcsuite/btcd/btcutil"
7	"github.com/lightningnetwork/lnd/lnrpc"
8	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
9	"github.com/lightningnetwork/lnd/lntest"
10	"github.com/lightningnetwork/lnd/lntest/node"
11	"github.com/lightningnetwork/lnd/lntest/rpc"
12	"github.com/lightningnetwork/lnd/lntest/wait"
13	"github.com/lightningnetwork/lnd/lntypes"
14	"github.com/lightningnetwork/lnd/lnwire"
15	"github.com/stretchr/testify/require"
16	)
17
18	// testExperimentalEndorsement tests setting of positive and negative
19	// experimental endorsement signals.
20	func testExperimentalEndorsement(ht *lntest.HarnessTest) {	×
21	testEndorsement(ht, true)	×
22	testEndorsement(ht, false)	×
23	}	×
24
25	// testEndorsement sets up a 5 hop network and tests propagation of
26	// experimental endorsement signals.
27	func testEndorsement(ht *lntest.HarnessTest, aliceEndorse bool) {	×
28	cfg := node.CfgAnchor	×
29	carolCfg := append(	×
30	[]string{"--protocol.no-experimental-endorsement"}, cfg...,	×
31	)	×
32	cfgs := [][]string{cfg, cfg, carolCfg, cfg, cfg}	×
33		×
34	const chanAmt = btcutil.Amount(300000)	×
35	p := lntest.OpenChannelParams{Amt: chanAmt}	×
36		×
37	_, nodes := ht.CreateSimpleNetwork(cfgs, p)	×
38	alice, bob, carol, dave, eve := nodes[0], nodes[1], nodes[2], nodes[3],	×
39	nodes[4]	×
40		×
41	bobIntercept, cancelBob := bob.RPC.HtlcInterceptor()	×
42	defer cancelBob()	×
43		×
44	carolIntercept, cancelCarol := carol.RPC.HtlcInterceptor()	×
45	defer cancelCarol()	×
46		×
47	daveIntercept, cancelDave := dave.RPC.HtlcInterceptor()	×
48	defer cancelDave()	×
49		×
50	req := &lnrpc.Invoice{ValueMsat: 1000}	×
51	addResponse := eve.RPC.AddInvoice(req)	×
52	invoice := eve.RPC.LookupInvoice(addResponse.RHash)	×
53		×
54	sendReq := &routerrpc.SendPaymentRequest{	×
55	PaymentRequest: invoice.PaymentRequest,	×
56	TimeoutSeconds: int32(wait.PaymentTimeout.Seconds()),	×
57	FeeLimitMsat: math.MaxInt64,	×
58	}	×
59		×
60	expectedValue := []byte{lnwire.ExperimentalUnendorsed}	×
61	if aliceEndorse {	×
62	expectedValue = []byte{lnwire.ExperimentalEndorsed}	×
63	t := uint64(lnwire.ExperimentalEndorsementType)	×
64	sendReq.FirstHopCustomRecords = map[uint64][]byte{	×
65	t: expectedValue,	×
66	}	×
67	}	×
68
69	_ = alice.RPC.SendPayment(sendReq)	×
70		×
71	// Validate that our signal (positive or zero) propagates until carol	×
72	// and then is dropped because she has disabled the feature.	×
73	validateEndorsedAndResume(ht, bobIntercept, true, expectedValue)	×
74	validateEndorsedAndResume(ht, carolIntercept, true, expectedValue)	×
75	validateEndorsedAndResume(ht, daveIntercept, false, nil)	×
76		×
77	var preimage lntypes.Preimage	×
78	copy(preimage[:], invoice.RPreimage)	×
NEW 79	ht.AssertPaymentStatus(alice, preimage.Hash(), lnrpc.Payment_SUCCEEDED)	×
80	}
81
82	func validateEndorsedAndResume(ht *lntest.HarnessTest,
83	interceptor rpc.InterceptorClient, hasEndorsement bool,
84	expectedValue []byte) {	×
85		×
86	packet := ht.ReceiveHtlcInterceptor(interceptor)	×
87		×
88	var expectedRecords map[uint64][]byte	×
89	if hasEndorsement {	×
90	u64Type := uint64(lnwire.ExperimentalEndorsementType)	×
91	expectedRecords = map[uint64][]byte{	×
92	u64Type: expectedValue,	×
93	}	×
94	}	×
95	require.Equal(ht, expectedRecords, packet.InWireCustomRecords)	×
96		×
97	err := interceptor.Send(&routerrpc.ForwardHtlcInterceptResponse{	×
98	IncomingCircuitKey: packet.IncomingCircuitKey,	×
99	Action: routerrpc.ResolveHoldForwardAction_RESUME,	×
100	})	×
101	require.NoError(ht, err)	×
102	}

lightningnetwork / lnd / 13589551993

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous