test(mempool): enhanced TestReactorNoBroadcastToSender (cometbft#4127)

The test should be able now to catch the error introduced by
cometbft#3657.

----

To see how it would break, please checkout the branch
`cason/test-nobroadcastsender`, then:

```
$ cd mempool
$ go test -v -run TestReactorNoBroadcastToSender
```

And wait it to fail, after 2 minutes. You are going to see the busy-loop
around, logs entries starting with `Skipping tx`, forever for the same
transaction.

Important: the test unit only works in the traditional mempool design,
without lanes. We should consider adding a variant of it that should
also pass when lanes are considered.

---

- [x] Tests written/updated
- [ ] Changelog entry added in `.changelog` (we use
[unclog](https://github.com/informalsystems/unclog) to manage our
changelog)
- [ ] Updated relevant documentation (`docs/` or `spec/`) and code
comments

---------

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

Author: 2 people

mempool/reactor_test.go

@@ -128,7 +128,7 @@ func TestReactorConcurrency(t *testing.T) {
 func TestReactorNoBroadcastToSender(t *testing.T) {
 	config := cfg.TestConfig()
 	const n = 2
-	reactors, _ := makeAndConnectReactors(config, n, nil)
+	reactors, _ := makeAndConnectReactorsNoLanes(config, n, nil)
 	defer func() {
 		for _, r := range reactors {
 			if err := r.Stop(); err != nil {
@@ -151,6 +151,7 @@ func TestReactorNoBroadcastToSender(t *testing.T) {
 
 	// The second peer sends some transactions to the first peer
 	secondNodeID := reactors[1].Switch.NodeInfo().ID()
+	secondNode := reactors[0].Switch.Peers().Get(secondNodeID)
 	for i, tx := range txs {
 		shouldBroadcast := cmtrand.Bool() || // random choice
 			// Force shouldBroadcast == true to ensure that
@@ -162,11 +163,11 @@ func TestReactorNoBroadcastToSender(t *testing.T) {
 
 		if !shouldBroadcast {
 			// From the second peer => should not be broadcast
-			_, err := reactors[0].mempool.CheckTx(tx, secondNodeID)
+			_, err := reactors[0].TryAddTx(tx, secondNode)
 			require.NoError(t, err)
 		} else {
 			// Emulate a tx received via RPC => should broadcast
-			_, err := reactors[0].mempool.CheckTx(tx, "")
+			_, err := reactors[0].TryAddTx(tx, nil)
 			require.NoError(t, err)
 			txsToBroadcast = append(txsToBroadcast, tx)
 		}
@@ -493,13 +494,18 @@ func mempoolLogger(level string) *log.Logger {
 }
 
 // makeReactors creates n mempool reactors.
-func makeReactors(config *cfg.Config, n int, logger *log.Logger) []*Reactor {
+func makeReactors(config *cfg.Config, n int, logger *log.Logger, lanesEnabled bool) []*Reactor {
 	if logger == nil {
 		logger = mempoolLogger("info")
 	}
 	reactors := make([]*Reactor, n)
 	for i := 0; i < n; i++ {
-		app := kvstore.NewInMemoryApplication()
+		var app *kvstore.Application
+		if lanesEnabled {
+			app = kvstore.NewInMemoryApplication()
+		} else {
+			app = kvstore.NewInMemoryApplicationWithoutLanes()
+		}
 		cc := proxy.NewLocalClientCreator(app)
 		mempool, cleanup := newMempoolWithApp(cc)
 		defer cleanup()
@@ -522,15 +528,21 @@ func connectReactors(config *cfg.Config, reactors []*Reactor, connect func([]*p2
 	return p2p.StartAndConnectSwitches(switches, connect)
 }
 
+func makeAndConnectReactorsNoLanes(config *cfg.Config, n int, logger *log.Logger) ([]*Reactor, []*p2p.Switch) {
+	reactors := makeReactors(config, n, logger, false)
+	switches := connectReactors(config, reactors, p2p.Connect2Switches)
+	return reactors, switches
+}
+
 func makeAndConnectReactors(config *cfg.Config, n int, logger *log.Logger) ([]*Reactor, []*p2p.Switch) {
-	reactors := makeReactors(config, n, logger)
+	reactors := makeReactors(config, n, logger, true)
 	switches := connectReactors(config, reactors, p2p.Connect2Switches)
 	return reactors, switches
 }
 
 // connect N mempool reactors through N switches as a star centered in c.
 func makeAndConnectReactorsStar(config *cfg.Config, c, n int, logger *log.Logger) ([]*Reactor, []*p2p.Switch) {
-	reactors := makeReactors(config, n, logger)
+	reactors := makeReactors(config, n, logger, true)
 	switches := connectReactors(config, reactors, p2p.ConnectStarSwitches(c))
 	return reactors, switches
 }