github.com/cryptohub-digital/blockbook-fork@v0.0.0-20230713133354-673c927af7f1/api/types_test.go (about)

     1  //go:build unittest
     2  
     3  package api
     4  
     5  import (
     6  	"encoding/json"
     7  	"math/big"
     8  	"reflect"
     9  	"sort"
    10  	"testing"
    11  )
    12  
    13  func TestAmount_MarshalJSON(t *testing.T) {
    14  	type amounts struct {
    15  		A1  Amount  `json:"a1"`
    16  		A2  Amount  `json:"a2,omitempty"`
    17  		PA1 *Amount `json:"pa1"`
    18  		PA2 *Amount `json:"pa2,omitempty"`
    19  	}
    20  	tests := []struct {
    21  		name string
    22  		a    amounts
    23  		want string
    24  	}{
    25  		{
    26  			name: "empty",
    27  			want: `{"a1":"0","a2":"0","pa1":null}`,
    28  		},
    29  		{
    30  			name: "1",
    31  			a: amounts{
    32  				A1:  (Amount)(*big.NewInt(123456)),
    33  				A2:  (Amount)(*big.NewInt(787901)),
    34  				PA1: (*Amount)(big.NewInt(234567)),
    35  				PA2: (*Amount)(big.NewInt(890123)),
    36  			},
    37  			want: `{"a1":"123456","a2":"787901","pa1":"234567","pa2":"890123"}`,
    38  		},
    39  	}
    40  	for _, tt := range tests {
    41  		t.Run(tt.name, func(t *testing.T) {
    42  			b, err := json.Marshal(&tt.a)
    43  			if err != nil {
    44  				t.Errorf("json.Marshal() error = %v", err)
    45  				return
    46  			}
    47  			if !reflect.DeepEqual(string(b), tt.want) {
    48  				t.Errorf("json.Marshal() = %v, want %v", string(b), tt.want)
    49  			}
    50  		})
    51  	}
    52  }
    53  
    54  func TestBalanceHistories_SortAndAggregate(t *testing.T) {
    55  	tests := []struct {
    56  		name        string
    57  		a           BalanceHistories
    58  		groupByTime uint32
    59  		want        BalanceHistories
    60  	}{
    61  		{
    62  			name:        "empty",
    63  			a:           []BalanceHistory{},
    64  			groupByTime: 3600,
    65  			want:        []BalanceHistory{},
    66  		},
    67  		{
    68  			name: "one",
    69  			a: []BalanceHistory{
    70  				{
    71  					ReceivedSat:   (*Amount)(big.NewInt(1)),
    72  					SentSat:       (*Amount)(big.NewInt(2)),
    73  					SentToSelfSat: (*Amount)(big.NewInt(1)),
    74  					Time:          1521514812,
    75  					Txid:          "00b2c06055e5e90e9c82bd4181fde310104391a7fa4f289b1704e5d90caa3840",
    76  					Txs:           1,
    77  				},
    78  			},
    79  			groupByTime: 3600,
    80  			want: []BalanceHistory{
    81  				{
    82  					ReceivedSat:   (*Amount)(big.NewInt(1)),
    83  					SentSat:       (*Amount)(big.NewInt(2)),
    84  					SentToSelfSat: (*Amount)(big.NewInt(1)),
    85  					Time:          1521514800,
    86  					Txs:           1,
    87  				},
    88  			},
    89  		},
    90  		{
    91  			name: "aggregate",
    92  			a: []BalanceHistory{
    93  				{
    94  					ReceivedSat:   (*Amount)(big.NewInt(1)),
    95  					SentSat:       (*Amount)(big.NewInt(2)),
    96  					SentToSelfSat: (*Amount)(big.NewInt(0)),
    97  					Time:          1521504812,
    98  					Txid:          "0011223344556677889900112233445566778899001122334455667788990011",
    99  					Txs:           1,
   100  				},
   101  				{
   102  					ReceivedSat:   (*Amount)(big.NewInt(3)),
   103  					SentSat:       (*Amount)(big.NewInt(4)),
   104  					SentToSelfSat: (*Amount)(big.NewInt(2)),
   105  					Time:          1521504812,
   106  					Txid:          "00b2c06055e5e90e9c82bd4181fde310104391a7fa4f289b1704e5d90caa3840",
   107  					Txs:           1,
   108  				},
   109  				{
   110  					ReceivedSat:   (*Amount)(big.NewInt(5)),
   111  					SentSat:       (*Amount)(big.NewInt(6)),
   112  					SentToSelfSat: (*Amount)(big.NewInt(3)),
   113  					Time:          1521514812,
   114  					Txid:          "00b2c06055e5e90e9c82bd4181fde310104391a7fa4f289b1704e5d90caa3840",
   115  					Txs:           1,
   116  				},
   117  				{
   118  					ReceivedSat:   (*Amount)(big.NewInt(7)),
   119  					SentSat:       (*Amount)(big.NewInt(8)),
   120  					SentToSelfSat: (*Amount)(big.NewInt(3)),
   121  					Time:          1521504812,
   122  					Txid:          "00b2c06055e5e90e9c82bd4181fde310104391a7fa4f289b1704e5d90caa3840",
   123  					Txs:           1,
   124  				},
   125  				{
   126  					ReceivedSat:   (*Amount)(big.NewInt(9)),
   127  					SentSat:       (*Amount)(big.NewInt(10)),
   128  					SentToSelfSat: (*Amount)(big.NewInt(5)),
   129  					Time:          1521534812,
   130  					Txid:          "0011223344556677889900112233445566778899001122334455667788990011",
   131  					Txs:           1,
   132  				},
   133  				{
   134  					ReceivedSat:   (*Amount)(big.NewInt(11)),
   135  					SentSat:       (*Amount)(big.NewInt(12)),
   136  					SentToSelfSat: (*Amount)(big.NewInt(6)),
   137  					Time:          1521534812,
   138  					Txid:          "1122334455667788990011223344556677889900112233445566778899001100",
   139  					Txs:           1,
   140  				},
   141  			},
   142  			groupByTime: 3600,
   143  			want: []BalanceHistory{
   144  				{
   145  					ReceivedSat:   (*Amount)(big.NewInt(11)),
   146  					SentSat:       (*Amount)(big.NewInt(14)),
   147  					SentToSelfSat: (*Amount)(big.NewInt(5)),
   148  					Time:          1521504000,
   149  					Txs:           2,
   150  				},
   151  				{
   152  					ReceivedSat:   (*Amount)(big.NewInt(5)),
   153  					SentSat:       (*Amount)(big.NewInt(6)),
   154  					SentToSelfSat: (*Amount)(big.NewInt(3)),
   155  					Time:          1521514800,
   156  					Txs:           1,
   157  				},
   158  				{
   159  					ReceivedSat:   (*Amount)(big.NewInt(20)),
   160  					SentSat:       (*Amount)(big.NewInt(22)),
   161  					SentToSelfSat: (*Amount)(big.NewInt(11)),
   162  					Time:          1521532800,
   163  					Txs:           2,
   164  				},
   165  			},
   166  		},
   167  	}
   168  	for _, tt := range tests {
   169  		t.Run(tt.name, func(t *testing.T) {
   170  			if got := tt.a.SortAndAggregate(tt.groupByTime); !reflect.DeepEqual(got, tt.want) {
   171  				t.Errorf("BalanceHistories.SortAndAggregate() = %+v, want %+v", got, tt.want)
   172  			}
   173  		})
   174  	}
   175  }
   176  
   177  func TestAmount_Compare(t *testing.T) {
   178  	tests := []struct {
   179  		name string
   180  		a    *Amount
   181  		b    *Amount
   182  		want int
   183  	}{
   184  		{
   185  			name: "nil-nil",
   186  			a:    nil,
   187  			b:    nil,
   188  			want: 0,
   189  		},
   190  		{
   191  			name: "20-nil",
   192  			a:    (*Amount)(big.NewInt(20)),
   193  			b:    nil,
   194  			want: 1,
   195  		},
   196  		{
   197  			name: "nil-20",
   198  			a:    nil,
   199  			b:    (*Amount)(big.NewInt(20)),
   200  			want: -1,
   201  		},
   202  		{
   203  			name: "18-20",
   204  			a:    (*Amount)(big.NewInt(18)),
   205  			b:    (*Amount)(big.NewInt(20)),
   206  			want: -1,
   207  		},
   208  		{
   209  			name: "20-20",
   210  			a:    (*Amount)(big.NewInt(20)),
   211  			b:    (*Amount)(big.NewInt(20)),
   212  			want: 0,
   213  		},
   214  	}
   215  	for _, tt := range tests {
   216  		t.Run(tt.name, func(t *testing.T) {
   217  			if got := tt.a.Compare(tt.b); got != tt.want {
   218  				t.Errorf("Amount.Compare() = %v, want %v", got, tt.want)
   219  			}
   220  		})
   221  	}
   222  }
   223  
   224  func TestTokens_Sort(t *testing.T) {
   225  	tests := []struct {
   226  		name     string
   227  		unsorted Tokens
   228  		sorted   Tokens
   229  	}{
   230  		{
   231  			name: "one",
   232  			unsorted: Tokens{
   233  				{
   234  					Name:      "a",
   235  					Contract:  "0x1",
   236  					BaseValue: 12.34,
   237  				},
   238  			},
   239  			sorted: Tokens{
   240  				{
   241  					Name:      "a",
   242  					Contract:  "0x1",
   243  					BaseValue: 12.34,
   244  				},
   245  			},
   246  		},
   247  		{
   248  			name: "mix",
   249  			unsorted: Tokens{
   250  				{
   251  					Name:      "",
   252  					Contract:  "0x6",
   253  					BaseValue: 0,
   254  				},
   255  				{
   256  					Name:      "",
   257  					Contract:  "0x5",
   258  					BaseValue: 0,
   259  				},
   260  				{
   261  					Name:      "b",
   262  					Contract:  "0x2",
   263  					BaseValue: 1,
   264  				},
   265  				{
   266  					Name:      "d",
   267  					Contract:  "0x4",
   268  					BaseValue: 0,
   269  				},
   270  				{
   271  					Name:      "a",
   272  					Contract:  "0x1",
   273  					BaseValue: 12.34,
   274  				},
   275  				{
   276  					Name:      "c",
   277  					Contract:  "0x3",
   278  					BaseValue: 0,
   279  				},
   280  			},
   281  			sorted: Tokens{
   282  				{
   283  					Name:      "a",
   284  					Contract:  "0x1",
   285  					BaseValue: 12.34,
   286  				},
   287  				{
   288  					Name:      "b",
   289  					Contract:  "0x2",
   290  					BaseValue: 1,
   291  				},
   292  				{
   293  					Name:      "c",
   294  					Contract:  "0x3",
   295  					BaseValue: 0,
   296  				},
   297  				{
   298  					Name:      "d",
   299  					Contract:  "0x4",
   300  					BaseValue: 0,
   301  				},
   302  				{
   303  					Name:      "",
   304  					Contract:  "0x5",
   305  					BaseValue: 0,
   306  				},
   307  				{
   308  					Name:      "",
   309  					Contract:  "0x6",
   310  					BaseValue: 0,
   311  				},
   312  			},
   313  		},
   314  	}
   315  	for _, tt := range tests {
   316  		t.Run(tt.name, func(t *testing.T) {
   317  			sort.Sort(tt.unsorted)
   318  			if !reflect.DeepEqual(tt.unsorted, tt.sorted) {
   319  				t.Errorf("Tokens Sort got %v, want %v", tt.unsorted, tt.sorted)
   320  			}
   321  		})
   322  	}
   323  }