account/builder_test.go

   1 package account
   2
   3 import (
   4         "testing"
   5         "time"
   6
   7         "github.com/vapor/blockchain/txbuilder"
   8         "github.com/vapor/consensus"
   9         "github.com/vapor/protocol/bc"
  10         "github.com/vapor/testutil"
  11 )
  12
  13 func TestMergeSpendAction(t *testing.T) {
  14         testBTM := &bc.AssetID{}
  15         if err := testBTM.UnmarshalText([]byte("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); err != nil {
  16                 t.Fatal(err)
  17         }
  18
  19         testAssetID1 := &bc.AssetID{}
  20         if err := testAssetID1.UnmarshalText([]byte("50ec80b6bc48073f6aa8fa045131a71213c33f3681203b15ddc2e4b81f1f4730")); err != nil {
  21                 t.Fatal(err)
  22         }
  23
  24         testAssetID2 := &bc.AssetID{}
  25         if err := testAssetID2.UnmarshalText([]byte("43c6946d092b2959c1a82e90b282c68fca63e66de289048f6acd6cea9383c79c")); err != nil {
  26                 t.Fatal(err)
  27         }
  28
  29         cases := []struct {
  30                 testActions     []txbuilder.Action
  31                 wantActions     []txbuilder.Action
  32                 testActionCount int
  33                 wantActionCount int
  34         }{
  35                 {
  36                         testActions: []txbuilder.Action{
  37                                 txbuilder.Action(&spendAction{
  38                                         AssetAmount: bc.AssetAmount{
  39                                                 AssetId: testBTM,
  40                                                 Amount:  100,
  41                                         },
  42                                         AccountID: "test_account",
  43                                 }),
  44                                 txbuilder.Action(&spendAction{
  45                                         AssetAmount: bc.AssetAmount{
  46                                                 AssetId: testBTM,
  47                                                 Amount:  200,
  48                                         },
  49                                         AccountID: "test_account",
  50                                 }),
  51                                 txbuilder.Action(&spendAction{
  52                                         AssetAmount: bc.AssetAmount{
  53                                                 AssetId: testBTM,
  54                                                 Amount:  300,
  55                                         },
  56                                         AccountID: "test_account",
  57                                 }),
  58                                 txbuilder.Action(&spendAction{
  59                                         AssetAmount: bc.AssetAmount{
  60                                                 AssetId: testAssetID1,
  61                                                 Amount:  300,
  62                                         },
  63                                         AccountID: "test_account",
  64                                 }),
  65                         },
  66                         wantActions: []txbuilder.Action{
  67                                 txbuilder.Action(&spendAction{
  68                                         AssetAmount: bc.AssetAmount{
  69                                                 AssetId: testBTM,
  70                                                 Amount:  600,
  71                                         },
  72                                         AccountID: "test_account",
  73                                 }),
  74                                 txbuilder.Action(&spendAction{
  75                                         AssetAmount: bc.AssetAmount{
  76                                                 AssetId: testAssetID1,
  77                                                 Amount:  300,
  78                                         },
  79                                         AccountID: "test_account",
  80                                 }),
  81                         },
  82                         testActionCount: 4,
  83                         wantActionCount: 2,
  84                 },
  85                 {
  86                         testActions: []txbuilder.Action{
  87                                 txbuilder.Action(&spendAction{
  88                                         AssetAmount: bc.AssetAmount{
  89                                                 AssetId: testBTM,
  90                                                 Amount:  100,
  91                                         },
  92                                         AccountID: "test_account",
  93                                 }),
  94                                 txbuilder.Action(&spendAction{
  95                                         AssetAmount: bc.AssetAmount{
  96                                                 AssetId: testAssetID1,
  97                                                 Amount:  200,
  98                                         },
  99                                         AccountID: "test_account",
 100                                 }),
 101                                 txbuilder.Action(&spendAction{
 102                                         AssetAmount: bc.AssetAmount{
 103                                                 AssetId: testBTM,
 104                                                 Amount:  500,
 105                                         },
 106                                         AccountID: "test_account",
 107                                 }),
 108                                 txbuilder.Action(&spendAction{
 109                                         AssetAmount: bc.AssetAmount{
 110                                                 AssetId: testAssetID1,
 111                                                 Amount:  300,
 112                                         },
 113                                         AccountID: "test_account",
 114                                 }),
 115                         },
 116                         wantActions: []txbuilder.Action{
 117                                 txbuilder.Action(&spendAction{
 118                                         AssetAmount: bc.AssetAmount{
 119                                                 AssetId: testBTM,
 120                                                 Amount:  600,
 121                                         },
 122                                         AccountID: "test_account",
 123                                 }),
 124                                 txbuilder.Action(&spendAction{
 125                                         AssetAmount: bc.AssetAmount{
 126                                                 AssetId: testAssetID1,
 127                                                 Amount:  500,
 128                                         },
 129                                         AccountID: "test_account",
 130                                 }),
 131                         },
 132                         testActionCount: 4,
 133                         wantActionCount: 2,
 134                 },
 135                 {
 136                         testActions: []txbuilder.Action{
 137                                 txbuilder.Action(&spendAction{
 138                                         AssetAmount: bc.AssetAmount{
 139                                                 AssetId: testBTM,
 140                                                 Amount:  100,
 141                                         },
 142                                         AccountID: "test_account",
 143                                 }),
 144                                 txbuilder.Action(&spendAction{
 145                                         AssetAmount: bc.AssetAmount{
 146                                                 AssetId: testAssetID1,
 147                                                 Amount:  200,
 148                                         },
 149                                         AccountID: "test_account",
 150                                 }),
 151                                 txbuilder.Action(&spendAction{
 152                                         AssetAmount: bc.AssetAmount{
 153                                                 AssetId: testAssetID2,
 154                                                 Amount:  300,
 155                                         },
 156                                         AccountID: "test_account",
 157                                 }),
 158                                 txbuilder.Action(&spendAction{
 159                                         AssetAmount: bc.AssetAmount{
 160                                                 AssetId: testAssetID1,
 161                                                 Amount:  300,
 162                                         },
 163                                         AccountID: "test_account",
 164                                 }),
 165                                 txbuilder.Action(&spendAction{
 166                                         AssetAmount: bc.AssetAmount{
 167                                                 AssetId: testAssetID2,
 168                                                 Amount:  500,
 169                                         },
 170                                         AccountID: "test_account",
 171                                 }),
 172                         },
 173                         wantActions: []txbuilder.Action{
 174                                 txbuilder.Action(&spendAction{
 175                                         AssetAmount: bc.AssetAmount{
 176                                                 AssetId: testBTM,
 177                                                 Amount:  100,
 178                                         },
 179                                         AccountID: "test_account",
 180                                 }),
 181                                 txbuilder.Action(&spendAction{
 182                                         AssetAmount: bc.AssetAmount{
 183                                                 AssetId: testAssetID1,
 184                                                 Amount:  500,
 185                                         },
 186                                         AccountID: "test_account",
 187                                 }),
 188                                 txbuilder.Action(&spendAction{
 189                                         AssetAmount: bc.AssetAmount{
 190                                                 AssetId: testAssetID2,
 191                                                 Amount:  800,
 192                                         },
 193                                         AccountID: "test_account",
 194                                 }),
 195                         },
 196                         testActionCount: 5,
 197                         wantActionCount: 3,
 198                 },
 199                 {
 200                         testActions: []txbuilder.Action{
 201                                 txbuilder.Action(&spendAction{
 202                                         AssetAmount: bc.AssetAmount{
 203                                                 AssetId: testBTM,
 204                                                 Amount:  100,
 205                                         },
 206                                         AccountID: "test_account",
 207                                 }),
 208                                 txbuilder.Action(&spendAction{
 209                                         AssetAmount: bc.AssetAmount{
 210                                                 AssetId: testBTM,
 211                                                 Amount:  200,
 212                                         },
 213                                         AccountID: "test_account1",
 214                                 }),
 215                                 txbuilder.Action(&spendAction{
 216                                         AssetAmount: bc.AssetAmount{
 217                                                 AssetId: testBTM,
 218                                                 Amount:  500,
 219                                         },
 220                                         AccountID: "test_account",
 221                                 }),
 222                                 txbuilder.Action(&spendAction{
 223                                         AssetAmount: bc.AssetAmount{
 224                                                 AssetId: testAssetID1,
 225                                                 Amount:  300,
 226                                         },
 227                                         AccountID: "test_account1",
 228                                 }),
 229                         },
 230                         wantActions: []txbuilder.Action{
 231                                 txbuilder.Action(&spendAction{
 232                                         AssetAmount: bc.AssetAmount{
 233                                                 AssetId: testBTM,
 234                                                 Amount:  600,
 235                                         },
 236                                         AccountID: "test_account",
 237                                 }),
 238                                 txbuilder.Action(&spendAction{
 239                                         AssetAmount: bc.AssetAmount{
 240                                                 AssetId: testBTM,
 241                                                 Amount:  200,
 242                                         },
 243                                         AccountID: "test_account1",
 244                                 }),
 245                                 txbuilder.Action(&spendAction{
 246                                         AssetAmount: bc.AssetAmount{
 247                                                 AssetId: testAssetID1,
 248                                                 Amount:  300,
 249                                         },
 250                                         AccountID: "test_account1",
 251                                 }),
 252                         },
 253                         testActionCount: 4,
 254                         wantActionCount: 3,
 255                 },
 256                 {
 257                         testActions: []txbuilder.Action{
 258                                 txbuilder.Action(&spendUTXOAction{
 259                                         OutputID: &bc.Hash{V0: 128},
 260                                 }),
 261                                 txbuilder.Action(&spendAction{
 262                                         AssetAmount: bc.AssetAmount{
 263                                                 AssetId: testBTM,
 264                                                 Amount:  100,
 265                                         },
 266                                         AccountID: "test_account",
 267                                 }),
 268                                 txbuilder.Action(&spendAction{
 269                                         AssetAmount: bc.AssetAmount{
 270                                                 AssetId: testAssetID1,
 271                                                 Amount:  200,
 272                                         },
 273                                         AccountID: "test_account1",
 274                                 }),
 275                                 txbuilder.Action(&spendUTXOAction{
 276                                         OutputID: &bc.Hash{V0: 256},
 277                                 }),
 278                                 txbuilder.Action(&spendAction{
 279                                         AssetAmount: bc.AssetAmount{
 280                                                 AssetId: testAssetID2,
 281                                                 Amount:  300,
 282                                         },
 283                                         AccountID: "test_account2",
 284                                 }),
 285                         },
 286                         wantActions: []txbuilder.Action{
 287                                 txbuilder.Action(&spendUTXOAction{
 288                                         OutputID: &bc.Hash{V0: 128},
 289                                 }),
 290                                 txbuilder.Action(&spendAction{
 291                                         AssetAmount: bc.AssetAmount{
 292                                                 AssetId: testBTM,
 293                                                 Amount:  100,
 294                                         },
 295                                         AccountID: "test_account",
 296                                 }),
 297                                 txbuilder.Action(&spendAction{
 298                                         AssetAmount: bc.AssetAmount{
 299                                                 AssetId: testAssetID1,
 300                                                 Amount:  200,
 301                                         },
 302                                         AccountID: "test_account1",
 303                                 }),
 304                                 txbuilder.Action(&spendUTXOAction{
 305                                         OutputID: &bc.Hash{V0: 256},
 306                                 }),
 307                                 txbuilder.Action(&spendAction{
 308                                         AssetAmount: bc.AssetAmount{
 309                                                 AssetId: testAssetID2,
 310                                                 Amount:  300,
 311                                         },
 312                                         AccountID: "test_account2",
 313                                 }),
 314                         },
 315                         testActionCount: 5,
 316                         wantActionCount: 5,
 317                 },
 318         }
 319
 320         for _, c := range cases {
 321                 gotActions := MergeSpendAction(c.testActions)
 322
 323                 gotMap := make(map[string]uint64)
 324                 wantMap := make(map[string]uint64)
 325                 for _, got := range gotActions {
 326                         switch got := got.(type) {
 327                         case *spendAction:
 328                                 gotKey := got.AssetId.String() + got.AccountID
 329                                 gotMap[gotKey] = got.Amount
 330                         default:
 331                                 continue
 332                         }
 333                 }
 334
 335                 for _, want := range c.wantActions {
 336                         switch want := want.(type) {
 337                         case *spendAction:
 338                                 wantKey := want.AssetId.String() + want.AccountID
 339                                 wantMap[wantKey] = want.Amount
 340                         default:
 341                                 continue
 342                         }
 343                 }
 344
 345                 for key := range gotMap {
 346                         if gotMap[key] != wantMap[key] {
 347                                 t.Fatalf("gotMap[%s]=%v, wantMap[%s]=%v", key, gotMap[key], key, wantMap[key])
 348                         }
 349                 }
 350
 351                 if len(gotActions) != c.wantActionCount {
 352                         t.Fatalf("number of gotActions=%d, wantActions=%d", len(gotActions), c.wantActionCount)
 353                 }
 354         }
 355 }
 356
 357 func TestCalcMergeGas(t *testing.T) {
 358         chainTxUtxoNum = 10
 359         cases := []struct {
 360                 utxoNum int
 361                 gas     uint64
 362         }{
 363                 {
 364                         utxoNum: 0,
 365                         gas:     0,
 366                 },
 367                 {
 368                         utxoNum: 1,
 369                         gas:     0,
 370                 },
 371                 {
 372                         utxoNum: 9,
 373                         gas:     chainTxMergeGas,
 374                 },
 375                 {
 376                         utxoNum: 10,
 377                         gas:     chainTxMergeGas,
 378                 },
 379                 {
 380                         utxoNum: 11,
 381                         gas:     chainTxMergeGas * 2,
 382                 },
 383                 {
 384                         utxoNum: 20,
 385                         gas:     chainTxMergeGas * 3,
 386                 },
 387                 {
 388                         utxoNum: 21,
 389                         gas:     chainTxMergeGas * 3,
 390                 },
 391                 {
 392                         utxoNum: 74,
 393                         gas:     chainTxMergeGas * 9,
 394                 },
 395         }
 396
 397         for i, c := range cases {
 398                 gas := calcMergeGas(c.utxoNum)
 399                 if gas != c.gas {
 400                         t.Fatalf("case %d got %d want %d", i, gas, c.gas)
 401                 }
 402         }
 403 }
 404
 405 func TestReserveBtmUtxoChain(t *testing.T) {
 406         chainTxUtxoNum = 3
 407         utxos := []*UTXO{}
 408         m := mockAccountManager(t)
 409         for i := uint64(1); i <= 20; i++ {
 410                 utxo := &UTXO{
 411                         OutputID:  bc.Hash{V0: i},
 412                         AccountID: "TestAccountID",
 413                         AssetID:   *consensus.BTMAssetID,
 414                         Amount:    i * chainTxMergeGas,
 415                 }
 416                 utxos = append(utxos, utxo)
 417
 418                 m.store.SetStandardUTXO(utxo.OutputID, utxo)
 419         }
 420
 421         cases := []struct {
 422                 amount uint64
 423                 want   []uint64
 424                 err    bool
 425         }{
 426                 {
 427                         amount: 1 * chainTxMergeGas,
 428                         want:   []uint64{1},
 429                 },
 430                 {
 431                         amount: 888888 * chainTxMergeGas,
 432                         want:   []uint64{},
 433                         err:    true,
 434                 },
 435                 {
 436                         amount: 7 * chainTxMergeGas,
 437                         want:   []uint64{4, 3, 1},
 438                 },
 439                 {
 440                         amount: 15 * chainTxMergeGas,
 441                         want:   []uint64{5, 4, 3, 2, 1, 6},
 442                 },
 443                 {
 444                         amount: 163 * chainTxMergeGas,
 445                         want:   []uint64{20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 2, 1, 3},
 446                 },
 447         }
 448
 449         for i, c := range cases {
 450                 m.utxoKeeper.expireReservation(time.Unix(999999999, 0))
 451                 utxos, err := m.reserveBtmUtxoChain(&txbuilder.TemplateBuilder{}, "TestAccountID", c.amount, false)
 452
 453                 if err != nil != c.err {
 454                         t.Fatalf("case %d got err %v want err = %v", i, err, c.err)
 455                 }
 456
 457                 got := []uint64{}
 458                 for _, utxo := range utxos {
 459                         got = append(got, utxo.Amount/chainTxMergeGas)
 460                 }
 461
 462                 if !testutil.DeepEqual(got, c.want) {
 463                         t.Fatalf("case %d got %d want %d", i, got, c.want)
 464                 }
 465         }
 466 }