github.com/angenalZZZ/gofunc@v0.0.0-20210507121333-48ff1be3917b/rpc/nats/subscriber_fastcache_test.go (about)

     1  package nats_test
     2  
     3  import (
     4  	"context"
     5  	"sync/atomic"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/angenalZZZ/gofunc/data"
    10  	"github.com/angenalZZZ/gofunc/data/random"
    11  	"github.com/angenalZZZ/gofunc/f"
    12  	nat "github.com/angenalZZZ/gofunc/rpc/nats"
    13  )
    14  
    15  func TestSubscriberFastCache(t *testing.T) {
    16  	// New Client Connect.
    17  	nat.Subject = "TestSubscriberFastCache"
    18  	nat.Conn, err = nat.New("nats.go", "", "", "HGJ766GR767FKJU0", "", "")
    19  	if err != nil {
    20  		t.Fatalf("[nats] failed to connect: %s\n", err.Error())
    21  	}
    22  
    23  	ctx, wait := f.ContextWithWait(context.Background())
    24  
    25  	// Create a subscriber for Client Connect.
    26  	sub := nat.NewSubscriberFastCache(nat.Conn, nat.Subject, data.RootDir)
    27  	sub.Hand = func(list [][]byte) error {
    28  		for _, item := range list {
    29  			if len(item) == 0 {
    30  				break
    31  			}
    32  			if item[0] != '{' {
    33  				t.Logf("[nats] received test message on %q: %s", sub.Subj, string(item))
    34  			}
    35  		}
    36  
    37  		f.DoneContext(ctx)
    38  		t.Logf("[nats] test finished on %q", sub.Subj)
    39  		return nil
    40  	}
    41  
    42  	// Ping a message.
    43  	go func() {
    44  		time.Sleep(time.Millisecond)
    45  		err = nat.Conn.Publish(sub.Subj, []byte("ping"))
    46  		if err != nil {
    47  			t.Fatalf("[nats] failed publishing a test message\t>\t%s", err.Error())
    48  		} else {
    49  			t.Logf("[nats] successful publishing a test message")
    50  		}
    51  	}()
    52  
    53  	sub.Run(wait)
    54  }
    55  
    56  // Take time 2.28s:60bytes, 4.58s:500bytes to process 1 million records,
    57  // run times 438596:60Bytes, 218340:500bytes Qps.(4CPU+16G+MHD)
    58  func TestBenchSubscriberFastCache(t *testing.T) {
    59  	// New Client Connect.
    60  	nat.Subject = "BenchmarkSubscriberFastCache"
    61  	nat.Conn, err = nat.New("nats.go", "", "", "HGJ766GR767FKJU0", "", "")
    62  	if err != nil {
    63  		t.Fatalf("[nats] failed to connect: %s\n", err.Error())
    64  	}
    65  
    66  	var publishedNumber, succeededNumber, failedNumber int64
    67  
    68  	// Create a subscriber for Client Connect.
    69  	sub := nat.NewSubscriberFastCache(nat.Conn, nat.Subject, data.RootDir)
    70  	sub.Hand = func(list [][]byte) error {
    71  		var n int64
    72  		for _, item := range list {
    73  			//Log.Info().Msgf("[nats] received message on %q: %s", sub.Subj, string(item))
    74  			if len(item) == 0 {
    75  				break
    76  			}
    77  			n++
    78  		}
    79  
    80  		atomic.AddInt64(&succeededNumber, n)
    81  		return nil
    82  	}
    83  
    84  	ctx, wait := f.ContextWithWait(context.TODO())
    85  	go sub.Run(wait)
    86  	time.Sleep(time.Millisecond)
    87  
    88  	var bufferData = random.AlphaNumberBytes(500)
    89  
    90  	// start benchmark test
    91  	t1 := time.Now()
    92  
    93  	// test publish pressure
    94  	for i := 0; i < 1000000; i++ {
    95  		err = nat.Conn.Publish(sub.Subj, bufferData)
    96  		if err != nil {
    97  			failedNumber++
    98  		} else {
    99  			publishedNumber++
   100  		}
   101  	}
   102  
   103  	// wait succeeded-number equals published-number
   104  	f.NumIncrWait(&publishedNumber, &succeededNumber)
   105  	t2 := time.Now()
   106  	ts := t2.Sub(t1)
   107  	time.Sleep(time.Millisecond)
   108  	f.DoneContext(ctx)
   109  
   110  	t.Logf("Publish Number: %d, Successful Number: %d, Failed Number %d", publishedNumber, succeededNumber, failedNumber)
   111  	t.Logf("Take time %s, handle received messages %d qps", ts, 1000*succeededNumber/ts.Milliseconds())
   112  }