github.com/TrueBlocks/trueblocks-core/src/apps/chifra@v0.0.0-20241022031540-b362680128f7/pkg/rpc/provider/key_test.go (about)

     1  package provider
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"io"
     7  	"net/http"
     8  	"net/http/httptest"
     9  	"reflect"
    10  	"testing"
    11  
    12  	"github.com/TrueBlocks/trueblocks-core/src/apps/chifra/pkg/base"
    13  	"github.com/TrueBlocks/trueblocks-core/src/apps/chifra/pkg/types"
    14  	"golang.org/x/time/rate"
    15  )
    16  
    17  func Test_keyPrepareQuery(t *testing.T) {
    18  	q := &Query{
    19  		Resources: []string{"one", "two"},
    20  	}
    21  	result := keyPrepareQuery(q)
    22  	if !reflect.DeepEqual(result.Resources, []string{"key"}) {
    23  		t.Fatal("wrong query")
    24  	}
    25  }
    26  
    27  func mockKeyServer(t *testing.T) (ts *httptest.Server) {
    28  	t.Helper()
    29  
    30  	pages := []keyResponseBody{
    31  		{
    32  			Data: []KeyAppearance{
    33  				{
    34  					BlockNumber:      "1",
    35  					TransactionIndex: "1",
    36  				},
    37  				{
    38  					BlockNumber:      "1",
    39  					TransactionIndex: "2",
    40  				},
    41  				{
    42  					BlockNumber:      "1",
    43  					TransactionIndex: "3",
    44  				},
    45  			},
    46  			Meta: Meta{
    47  				PreviousPageId: "second",
    48  			},
    49  		},
    50  		{
    51  			Data: []KeyAppearance{
    52  				{
    53  					BlockNumber:      "2",
    54  					TransactionIndex: "1",
    55  				},
    56  			},
    57  		},
    58  	}
    59  	ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    60  		var request struct {
    61  			Params []keyAppearancesRequestParam `json:"params"`
    62  		}
    63  		var result struct {
    64  			Result keyResponseBody `json:"result"`
    65  		}
    66  
    67  		body, err := io.ReadAll(r.Body)
    68  		if err != nil {
    69  			t.Fatal(err)
    70  		}
    71  		defer r.Body.Close()
    72  		if err := json.Unmarshal(body, &request); err != nil {
    73  			t.Fatal(err)
    74  		}
    75  
    76  		switch request.Params[0].PageId {
    77  		case "":
    78  			fallthrough
    79  		case "latest":
    80  			result.Result = pages[0]
    81  			result.Result.Meta.PreviousPageId = "second"
    82  		case "second":
    83  			result.Result = pages[1]
    84  			result.Result.Meta.PreviousPageId = ""
    85  		default:
    86  			result.Result = keyResponseBody{}
    87  			result.Result.Meta.PreviousPageId = ""
    88  		}
    89  
    90  		w.Header().Set("Content-Type", "application/json")
    91  
    92  		b, err := json.Marshal(result)
    93  		if err != nil {
    94  			t.Fatal(err)
    95  		}
    96  		w.Write(b)
    97  	}))
    98  
    99  	return ts
   100  }
   101  
   102  func TestKeyProvider_Appearances(t *testing.T) {
   103  	perPage := 3
   104  	ts := mockKeyServer(t)
   105  	defer ts.Close()
   106  
   107  	provider := KeyProvider{
   108  		perPage: perPage,
   109  		baseUrl: ts.URL,
   110  	}
   111  	provider.limiter = rate.NewLimiter(5, 5)
   112  
   113  	query := &Query{
   114  		Addresses: []base.Address{
   115  			base.HexToAddress("0xf503017d7baf7fbc0fff7492b751025c6a78179b"),
   116  		},
   117  		Resources: []string{"int"},
   118  	}
   119  	ctx, cancel := context.WithCancel(context.Background())
   120  	defer cancel()
   121  	errors := make(chan error)
   122  	results := provider.Appearances(ctx, query, errors)
   123  
   124  	count := 0
   125  LOOP:
   126  	for {
   127  		select {
   128  		case err, ok := <-errors:
   129  			if ok {
   130  				cancel()
   131  				t.Fatal(err)
   132  			}
   133  		case data, ok := <-results:
   134  			if !ok {
   135  				break LOOP
   136  			}
   137  			t.Log("got data", data)
   138  			count++
   139  		}
   140  	}
   141  
   142  	if count != 4 {
   143  		t.Fatal("wrong count:", count)
   144  	}
   145  }
   146  
   147  func TestKeyProvider_Count(t *testing.T) {
   148  	perPage := 3
   149  	ts := mockKeyServer(t)
   150  	defer ts.Close()
   151  
   152  	provider := KeyProvider{
   153  		perPage: perPage,
   154  		baseUrl: ts.URL,
   155  	}
   156  	provider.limiter = rate.NewLimiter(5, 5)
   157  
   158  	query := &Query{
   159  		Addresses: []base.Address{
   160  			base.HexToAddress("0xf503017d7baf7fbc0fff7492b751025c6a78179b"),
   161  		},
   162  		Resources: []string{"int"},
   163  	}
   164  	ctx, cancel := context.WithCancel(context.Background())
   165  	defer cancel()
   166  	errors := make(chan error)
   167  
   168  	results := provider.Count(ctx, query, errors)
   169  
   170  	count := make([]types.Monitor, 0, 1)
   171  LOOP:
   172  	for {
   173  		select {
   174  		case err, ok := <-errors:
   175  			if ok {
   176  				cancel()
   177  				t.Fatal(err)
   178  			}
   179  		case data, ok := <-results:
   180  			if !ok {
   181  				break LOOP
   182  			}
   183  			count = append(count, data)
   184  
   185  		}
   186  	}
   187  
   188  	if l := len(count); l != 1 {
   189  		t.Fatal("wrong len:", l)
   190  	}
   191  	if n := count[0].NRecords; n != 4 {
   192  		t.Fatal("wrong NRecords", n)
   193  	}
   194  }