gitlab.nesad.fit.vutbr.cz/blended/libblended@v0.0.0-20221202124402-2bee159339df/ethereum/contract_test.go (about) 1 package ethereum_test 2 3 import ( 4 "encoding/hex" 5 "github.com/ethereum/go-ethereum/accounts/abi/bind" 6 "github.com/ethereum/go-ethereum/common" 7 "github.com/ethereum/go-ethereum/core/types" 8 "github.com/ethereum/go-ethereum/ethclient" 9 "github.com/stretchr/testify/assert" 10 "gitlab.nesad.fit.vutbr.cz/blended/libblended/ethereum" 11 "math/big" 12 "os" 13 "testing" 14 "time" 15 ) 16 17 func createTestConnection(t *testing.T) (*ethclient.Client, error) { 18 ethereumIp, exists := os.LookupEnv("ETHEREUM_IP") 19 20 assert.True(t, exists) 21 assert.NotNil(t, ethereumIp) 22 23 client, err := ethclient.Dial("ws://" + ethereumIp) 24 assert.Nil(t, err) 25 assert.NotNil(t, client) 26 27 return client, err 28 } 29 30 func createTestTransactor(t *testing.T) (*bind.TransactOpts, error) { 31 transactor, err := ethereum.CreateTransactor("./accounts/keystore/UTC--2020-04-22T11-57-05.940092181Z--26b0a62f5370f4640e7e2e5f800ab1f79dd03f34", "tester") 32 33 assert.Nil(t, err) 34 assert.NotNil(t, transactor) 35 36 transactor.GasLimit = 4700000 37 38 return transactor, err 39 } 40 41 func TestDeployTask(t *testing.T) { 42 transactor, err := createTestTransactor(t) 43 44 client, err := createTestConnection(t) 45 defer client.Close() 46 47 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 48 49 assert.Nil(t, err) 50 assert.NotNil(t, addr) 51 assert.NotNil(t, tx) 52 assert.NotNil(t, task) 53 } 54 55 func TestPollForTransaction(t *testing.T) { 56 transactor, err := createTestTransactor(t) 57 58 client, err := createTestConnection(t) 59 defer client.Close() 60 61 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 62 63 assert.Nil(t, err) 64 assert.NotNil(t, addr) 65 assert.NotNil(t, tx) 66 assert.NotNil(t, task) 67 68 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(30)*time.Second) 69 assert.Nil(t, err) 70 assert.NotNil(t, receipt) 71 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 72 } 73 74 //func debug(t *testing.T, task *ethereum.Task) { 75 //debug_ch := make(chan *ethereum.TaskDebug) 76 //subscription, err := task.TaskFilterer.WatchDebug(nil, debug_ch) 77 //assert.Nil(t, err) 78 //t.Log("XXXXXXXXXXXXXXX") 79 //for { 80 //select { 81 //case err := <-subscription.Err(): 82 //t.Log("YYYYYYYYYYYYY") 83 //t.Log(err) 84 //case vLog := <-debug_ch: 85 //t.Log("ZZZZZZZZZZZZZZ") 86 //t.Log(string(vLog.Message)) 87 //} 88 //} 89 //} 90 91 func TestAddAndAckPlatformAndApplicationRequest(t *testing.T) { 92 transactor, err := createTestTransactor(t) 93 94 client, err := createTestConnection(t) 95 defer client.Close() 96 97 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 98 99 assert.Nil(t, err) 100 assert.NotNil(t, addr) 101 assert.NotNil(t, tx) 102 assert.NotNil(t, task) 103 104 tx, err = task.SetPlatformRequest( 105 transactor, 106 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 107 []byte("ASB")) 108 109 tx, err = task.SetApplicationRequest( 110 transactor, 111 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 112 []byte("app-uuid"), 113 []byte("app-name"), 114 ) 115 116 tx, err = task.LockResourceRequests(transactor) 117 assert.Nil(t, err) 118 assert.NotNil(t, tx) 119 120 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 121 assert.Nil(t, err) 122 assert.NotNil(t, receipt) 123 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 124 125 tx, err = task.AckPlatformRequest(transactor, []byte("")) 126 assert.Nil(t, err) 127 assert.NotNil(t, tx) 128 129 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 130 assert.Nil(t, err) 131 assert.NotNil(t, receipt) 132 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 133 134 tx, err = task.AckApplicationRequest(transactor) 135 assert.Nil(t, err) 136 assert.NotNil(t, tx) 137 138 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 139 assert.Nil(t, err) 140 assert.NotNil(t, receipt) 141 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 142 } 143 144 func TestAddAndAckResourceRequest(t *testing.T) { 145 transactor, err := createTestTransactor(t) 146 147 client, err := createTestConnection(t) 148 defer client.Close() 149 150 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 151 152 assert.Nil(t, err) 153 assert.NotNil(t, addr) 154 assert.NotNil(t, tx) 155 assert.NotNil(t, task) 156 157 tx, err = task.AddResourceRequest( 158 transactor, 159 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 160 []byte("123"), 161 []byte("param_name_1"), 162 ) 163 assert.Nil(t, err) 164 assert.NotNil(t, tx) 165 166 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 167 assert.Nil(t, err) 168 assert.NotNil(t, receipt) 169 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 170 171 tx, err = task.SetPlatformRequest( 172 transactor, 173 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 174 []byte("ASB")) 175 assert.Nil(t, err) 176 assert.NotNil(t, tx) 177 178 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 179 assert.Nil(t, err) 180 assert.NotNil(t, receipt) 181 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 182 183 tx, err = task.SetApplicationRequest( 184 transactor, 185 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 186 []byte("app-uuid"), 187 []byte("app-name"), 188 ) 189 assert.Nil(t, err) 190 assert.NotNil(t, tx) 191 192 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 193 assert.Nil(t, err) 194 assert.NotNil(t, receipt) 195 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 196 197 tx, err = task.LockResourceRequests(transactor) 198 assert.Nil(t, err) 199 assert.NotNil(t, tx) 200 201 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 202 assert.Nil(t, err) 203 assert.NotNil(t, receipt) 204 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 205 206 tx, err = task.AckPlatformRequest(transactor, []byte("")) 207 assert.Nil(t, err) 208 assert.NotNil(t, tx) 209 210 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 211 assert.Nil(t, err) 212 assert.NotNil(t, receipt) 213 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 214 215 tx, err = task.AckApplicationRequest(transactor) 216 assert.Nil(t, err) 217 assert.NotNil(t, tx) 218 219 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 220 assert.Nil(t, err) 221 assert.NotNil(t, receipt) 222 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 223 224 tx, err = task.AckResourceRequest(transactor, big.NewInt(0), []byte("321"), []byte("some_ipfs_address")) 225 assert.Nil(t, err) 226 assert.NotNil(t, tx) 227 228 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 229 assert.Nil(t, err) 230 assert.NotNil(t, receipt) 231 assert.Equal(t, uint64(0x0), receipt.Status, "Transaction succeeded and was supposed to fail") 232 233 tx, err = task.AckResourceRequest(transactor, big.NewInt(0), []byte("123"), []byte("some_ipfs_address")) 234 assert.Nil(t, err) 235 assert.NotNil(t, tx) 236 237 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 238 assert.Nil(t, err) 239 assert.NotNil(t, receipt) 240 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 241 242 t.Log("Task address", addr.Hex()) 243 logTask(t, task) 244 } 245 246 func TestSetResultSecPolicy(t *testing.T) { 247 transactor, err := createTestTransactor(t) 248 249 client, err := createTestConnection(t) 250 defer client.Close() 251 252 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 253 254 assert.Nil(t, err) 255 assert.NotNil(t, addr) 256 assert.NotNil(t, tx) 257 assert.NotNil(t, task) 258 259 tx, err = task.SetResultsSecurityPolicy( 260 transactor, 261 []byte("{\"type\":\"gpg\", \"recipients\":\"12BABA6BADB8C1F63D0D5ED9BAF6C9AF1B0B82AE\"}")) 262 assert.Nil(t, err) 263 assert.NotNil(t, tx) 264 265 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 266 assert.Nil(t, err) 267 assert.NotNil(t, receipt) 268 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 269 270 tx, err = task.SetPlatformRequest( 271 transactor, 272 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 273 []byte("ASB")) 274 assert.Nil(t, err) 275 assert.NotNil(t, tx) 276 277 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 278 assert.Nil(t, err) 279 assert.NotNil(t, receipt) 280 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 281 282 tx, err = task.LockResourceRequests(transactor) 283 assert.Nil(t, err) 284 assert.NotNil(t, tx) 285 286 tx, err = task.SetResultsSecurityPolicy( 287 transactor, 288 []byte("{\"type\":\"gpg\", \"recipients\":\"should fail\"}")) 289 assert.Nil(t, err) 290 assert.NotNil(t, tx) 291 292 t.Log("Task address", addr.Hex()) 293 logTask(t, task) 294 } 295 296 func TestAckPlatformWithSecPolicy(t *testing.T) { 297 transactor, err := createTestTransactor(t) 298 299 client, err := createTestConnection(t) 300 defer client.Close() 301 302 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 303 304 assert.Nil(t, err) 305 assert.NotNil(t, addr) 306 assert.NotNil(t, tx) 307 assert.NotNil(t, task) 308 309 tx, err = task.SetPlatformRequest( 310 transactor, 311 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 312 []byte("ASB")) 313 assert.Nil(t, err) 314 assert.NotNil(t, tx) 315 316 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 317 assert.Nil(t, err) 318 assert.NotNil(t, receipt) 319 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 320 321 tx, err = task.SetApplicationRequest( 322 transactor, 323 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 324 []byte("app-uuid"), 325 []byte("app-name"), 326 ) 327 assert.Nil(t, err) 328 assert.NotNil(t, tx) 329 330 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 331 assert.Nil(t, err) 332 assert.NotNil(t, receipt) 333 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 334 335 tx, err = task.LockResourceRequests(transactor) 336 assert.Nil(t, err) 337 assert.NotNil(t, tx) 338 339 tx, err = task.AckPlatformRequest(transactor, []byte("{\"type\":\"gpg\", \"recipients\":\"12BABA6BADB8C1F63D0D5ED9BAF6C9AF1B0B82AE\"}")) 340 assert.Nil(t, err) 341 assert.NotNil(t, tx) 342 343 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 344 assert.Nil(t, err) 345 assert.NotNil(t, receipt) 346 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 347 348 t.Log("Task address", addr.Hex()) 349 logTask(t, task) 350 } 351 352 func TestResourceRequestAfterLock(t *testing.T) { 353 transactor, err := createTestTransactor(t) 354 355 client, err := createTestConnection(t) 356 defer client.Close() 357 358 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 359 360 assert.Nil(t, err) 361 assert.NotNil(t, addr) 362 assert.NotNil(t, tx) 363 assert.NotNil(t, task) 364 365 tx, err = task.SetPlatformRequest( 366 transactor, 367 common.HexToAddress("0x125100c1ccDD49B58f4E0bD66C1A8CD808602558"), 368 []byte("ASB")) 369 assert.Nil(t, err) 370 assert.NotNil(t, tx) 371 372 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 373 assert.Nil(t, err) 374 assert.NotNil(t, receipt) 375 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 376 377 tx, err = task.SetApplicationRequest( 378 transactor, 379 common.HexToAddress("0x125100c1ccDD49B58f4E0bD66C1A8CD808602558"), 380 []byte("app-uuid"), 381 []byte("app-name"), 382 ) 383 assert.Nil(t, err) 384 assert.NotNil(t, tx) 385 386 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 387 assert.Nil(t, err) 388 assert.NotNil(t, receipt) 389 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 390 391 tx, err = task.LockResourceRequests(transactor) 392 assert.Nil(t, err) 393 assert.NotNil(t, tx) 394 395 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 396 assert.Nil(t, err) 397 assert.NotNil(t, receipt) 398 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 399 400 tx, err = task.AddResourceRequest( 401 transactor, 402 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 403 []byte("321"), 404 []byte("param_name_1"), 405 ) 406 assert.Nil(t, err) 407 assert.NotNil(t, tx) 408 409 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 410 assert.Nil(t, err) 411 assert.NotNil(t, receipt) 412 assert.Equal(t, uint64(0x0), receipt.Status, "Transaction succeeded and was supposed to fail") 413 414 t.Log("Task address", addr.Hex()) 415 logTask(t, task) 416 } 417 418 func TestAddAndNackResourceRequest(t *testing.T) { 419 transactor, err := createTestTransactor(t) 420 421 client, err := createTestConnection(t) 422 defer client.Close() 423 424 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 425 426 assert.Nil(t, err) 427 assert.NotNil(t, addr) 428 assert.NotNil(t, tx) 429 assert.NotNil(t, task) 430 431 tx, err = task.AddResourceRequest( 432 transactor, 433 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 434 []byte("321"), 435 []byte("param_name_1"), 436 ) 437 assert.Nil(t, err) 438 assert.NotNil(t, tx) 439 440 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 441 assert.Nil(t, err) 442 assert.NotNil(t, receipt) 443 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 444 445 tx, err = task.SetPlatformRequest( 446 transactor, 447 common.HexToAddress("0x125100c1ccDD49B58f4E0bD66C1A8CD808602558"), 448 []byte("ASB")) 449 assert.Nil(t, err) 450 assert.NotNil(t, tx) 451 452 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 453 assert.Nil(t, err) 454 assert.NotNil(t, receipt) 455 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 456 457 tx, err = task.SetApplicationRequest( 458 transactor, 459 common.HexToAddress("0x125100c1ccDD49B58f4E0bD66C1A8CD808602558"), 460 []byte("app-uuid"), 461 []byte("app-name"), 462 ) 463 assert.Nil(t, err) 464 assert.NotNil(t, tx) 465 466 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 467 assert.Nil(t, err) 468 assert.NotNil(t, receipt) 469 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 470 471 tx, err = task.LockResourceRequests(transactor) 472 assert.Nil(t, err) 473 assert.NotNil(t, tx) 474 475 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 476 assert.Nil(t, err) 477 assert.NotNil(t, receipt) 478 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 479 480 tx, err = task.NackResourceRequest(transactor, big.NewInt(0), []byte("321")) 481 assert.Nil(t, err) 482 assert.NotNil(t, tx) 483 484 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 485 assert.Nil(t, err) 486 assert.NotNil(t, receipt) 487 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 488 489 t.Log("Task address", addr.Hex()) 490 logTask(t, task) 491 } 492 493 func TestRunTask(t *testing.T) { 494 transactor, err := createTestTransactor(t) 495 496 client, err := createTestConnection(t) 497 defer client.Close() 498 499 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 500 501 assert.Nil(t, err) 502 assert.NotNil(t, addr) 503 assert.NotNil(t, tx) 504 assert.NotNil(t, task) 505 506 tx, err = task.AddResourceRequest( 507 transactor, 508 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 509 []byte("321"), 510 []byte("param_name_1"), 511 ) 512 assert.Nil(t, err) 513 assert.NotNil(t, tx) 514 515 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 516 assert.Nil(t, err) 517 assert.NotNil(t, receipt) 518 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 519 520 tx, err = task.SetPlatformRequest( 521 transactor, 522 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 523 []byte("ASB")) 524 assert.Nil(t, err) 525 assert.NotNil(t, tx) 526 527 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 528 assert.Nil(t, err) 529 assert.NotNil(t, receipt) 530 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 531 532 tx, err = task.SetApplicationRequest( 533 transactor, 534 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 535 []byte("app-uuid"), 536 []byte("app-name"), 537 ) 538 assert.Nil(t, err) 539 assert.NotNil(t, tx) 540 541 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 542 assert.Nil(t, err) 543 assert.NotNil(t, receipt) 544 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 545 546 tx, err = task.LockResourceRequests(transactor) 547 assert.Nil(t, err) 548 assert.NotNil(t, tx) 549 550 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 551 assert.Nil(t, err) 552 assert.NotNil(t, receipt) 553 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 554 555 tx, err = task.AckPlatformRequest(transactor, []byte("")) 556 assert.Nil(t, err) 557 assert.NotNil(t, tx) 558 559 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 560 assert.Nil(t, err) 561 assert.NotNil(t, receipt) 562 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 563 564 tx, err = task.AckApplicationRequest(transactor) 565 assert.Nil(t, err) 566 assert.NotNil(t, tx) 567 568 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 569 assert.Nil(t, err) 570 assert.NotNil(t, receipt) 571 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 572 573 tx, err = task.AckResourceRequest(transactor, big.NewInt(0), []byte("321"), []byte("some_ipfs_address")) 574 assert.Nil(t, err) 575 assert.NotNil(t, tx) 576 577 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 578 assert.Nil(t, err) 579 assert.NotNil(t, receipt) 580 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 581 582 tx, err = task.RunTask(transactor, []byte("execution/1")) 583 assert.Nil(t, err) 584 assert.NotNil(t, tx) 585 586 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 587 assert.Nil(t, err) 588 assert.NotNil(t, receipt) 589 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 590 } 591 592 func TestRunTaskFail(t *testing.T) { 593 transactor, err := createTestTransactor(t) 594 595 client, err := createTestConnection(t) 596 defer client.Close() 597 598 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 599 600 assert.Nil(t, err) 601 assert.NotNil(t, addr) 602 assert.NotNil(t, tx) 603 assert.NotNil(t, task) 604 605 tx, err = task.AddResourceRequest( 606 transactor, 607 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 608 []byte("321"), 609 []byte("param_name_1"), 610 ) 611 assert.Nil(t, err) 612 assert.NotNil(t, tx) 613 614 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 615 assert.Nil(t, err) 616 assert.NotNil(t, receipt) 617 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 618 619 tx, err = task.SetPlatformRequest( 620 transactor, 621 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 622 []byte("ASB")) 623 assert.Nil(t, err) 624 assert.NotNil(t, tx) 625 626 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 627 assert.Nil(t, err) 628 assert.NotNil(t, receipt) 629 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 630 631 tx, err = task.SetApplicationRequest( 632 transactor, 633 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 634 []byte("app-uuid"), 635 []byte("app-name"), 636 ) 637 assert.Nil(t, err) 638 assert.NotNil(t, tx) 639 640 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 641 assert.Nil(t, err) 642 assert.NotNil(t, receipt) 643 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 644 645 tx, err = task.LockResourceRequests(transactor) 646 assert.Nil(t, err) 647 assert.NotNil(t, tx) 648 649 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 650 assert.Nil(t, err) 651 assert.NotNil(t, receipt) 652 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 653 654 tx, err = task.AckPlatformRequest(transactor, []byte("")) 655 assert.Nil(t, err) 656 assert.NotNil(t, tx) 657 658 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 659 assert.Nil(t, err) 660 assert.NotNil(t, receipt) 661 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 662 663 tx, err = task.AckApplicationRequest(transactor) 664 assert.Nil(t, err) 665 assert.NotNil(t, tx) 666 667 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 668 assert.Nil(t, err) 669 assert.NotNil(t, receipt) 670 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 671 672 tx, err = task.AckResourceRequest(transactor, big.NewInt(0), []byte("321"), []byte("some_ipfs_address")) 673 assert.Nil(t, err) 674 assert.NotNil(t, tx) 675 676 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 677 assert.Nil(t, err) 678 assert.NotNil(t, receipt) 679 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 680 681 tx, err = task.RunTaskFail(transactor, []byte("couldn't submit task for execution, incorrect parameters")) 682 assert.Nil(t, err) 683 assert.NotNil(t, tx) 684 685 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 686 assert.Nil(t, err) 687 assert.NotNil(t, receipt) 688 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 689 690 t.Log("Task address", addr.Hex()) 691 logTask(t, task) 692 } 693 694 func TestAddAndLockTaskResults(t *testing.T) { 695 transactor, err := createTestTransactor(t) 696 697 client, err := createTestConnection(t) 698 defer client.Close() 699 700 addr, tx, task, err := ethereum.DeployTask(transactor, client, transactor.From) 701 702 assert.Nil(t, err) 703 assert.NotNil(t, addr) 704 assert.NotNil(t, tx) 705 assert.NotNil(t, task) 706 707 tx, err = task.AddResourceRequest( 708 transactor, 709 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 710 []byte("321"), 711 []byte("param_name_1"), 712 ) 713 assert.Nil(t, err) 714 assert.NotNil(t, tx) 715 716 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 717 assert.Nil(t, err) 718 assert.NotNil(t, receipt) 719 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 720 721 tx, err = task.SetPlatformRequest( 722 transactor, 723 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 724 []byte("ASB")) 725 assert.Nil(t, err) 726 assert.NotNil(t, tx) 727 728 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 729 assert.Nil(t, err) 730 assert.NotNil(t, receipt) 731 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 732 733 tx, err = task.SetApplicationRequest( 734 transactor, 735 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 736 []byte("app-uuid"), 737 []byte("app-name"), 738 ) 739 assert.Nil(t, err) 740 assert.NotNil(t, tx) 741 742 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 743 assert.Nil(t, err) 744 assert.NotNil(t, receipt) 745 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 746 747 tx, err = task.LockResourceRequests(transactor) 748 assert.Nil(t, err) 749 assert.NotNil(t, tx) 750 751 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 752 assert.Nil(t, err) 753 assert.NotNil(t, receipt) 754 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 755 756 tx, err = task.AckPlatformRequest(transactor, []byte("")) 757 assert.Nil(t, err) 758 assert.NotNil(t, tx) 759 760 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 761 assert.Nil(t, err) 762 assert.NotNil(t, receipt) 763 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 764 765 tx, err = task.AckApplicationRequest(transactor) 766 assert.Nil(t, err) 767 assert.NotNil(t, tx) 768 769 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 770 assert.Nil(t, err) 771 assert.NotNil(t, receipt) 772 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 773 774 tx, err = task.AckResourceRequest(transactor, big.NewInt(0), []byte("321"), []byte("some_ipfs_address")) 775 assert.Nil(t, err) 776 assert.NotNil(t, tx) 777 778 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 779 assert.Nil(t, err) 780 assert.NotNil(t, receipt) 781 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 782 783 tx, err = task.RunTask(transactor, []byte("execution/2")) 784 assert.Nil(t, err) 785 assert.NotNil(t, tx) 786 787 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 788 assert.Nil(t, err) 789 assert.NotNil(t, receipt) 790 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 791 792 tx, err = task.AddTaskResult( 793 transactor, 794 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 795 []byte("result_ipfs_address")) 796 assert.Nil(t, err) 797 assert.NotNil(t, tx) 798 799 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 800 assert.Nil(t, err) 801 assert.NotNil(t, receipt) 802 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 803 804 tx, err = task.LockResults(transactor) 805 assert.Nil(t, err) 806 assert.NotNil(t, tx) 807 808 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 809 assert.Nil(t, err) 810 assert.NotNil(t, receipt) 811 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 812 } 813 814 func logTask(t *testing.T, task *ethereum.Task) { 815 requests, err := task.GetResourceRequests(nil) 816 assert.Nil(t, err) 817 assert.NotNil(t, requests) 818 owner, _ := task.TaskOwner(nil) 819 task_state, _ := task.TaskState(nil) 820 results_security_policy, err := task.ResultsSecurityPolicy(nil) 821 t.Log("Taskowner: ", owner.Hex()) 822 t.Log("Task state", task_state) 823 t.Log("Results security policy: ", string(results_security_policy)) 824 825 t.Log("Platform request:") 826 platform_request, _ := task.PlatformRequest(nil) 827 t.Log("\towner:", platform_request.Owner.Hex()) 828 t.Log("\tCatalogUUID:", string(platform_request.CatalogUuid)) 829 t.Log("\tCatalogUUIDHash:", string(hex.EncodeToString(platform_request.CatalogUuidHash[:]))) 830 t.Log("\tack:", platform_request.Ack) 831 t.Log("\tack_status:", platform_request.AckStatus) 832 t.Log("\texecution_id:", string(platform_request.PlatformExecutionId)) 833 t.Log("\tsecurity_policy:", string(platform_request.SecurityPolicy)) 834 835 t.Log("Application request:") 836 application_request, _ := task.ApplicationRequest(nil) 837 t.Log("\towner:", application_request.Owner.Hex()) 838 t.Log("\tCatalogUUID:", string(application_request.CatalogUuid)) 839 t.Log("\tCatalogUUIDHash:", string(hex.EncodeToString(application_request.CatalogUuidHash[:]))) 840 t.Log("\tapplication name:", string(application_request.ApplicationName)) 841 t.Log("\tack:", application_request.Ack) 842 t.Log("\tack_status:", application_request.AckStatus) 843 844 t.Log("Status of Resource Requests:") 845 for i, r := range requests { 846 t.Log("\tTask Request #", i) 847 t.Log("\towner", r.Owner.Hex()) 848 t.Log("\tCatalogUUID", string(r.CatalogUuid)) 849 t.Log("\tCatalogUUIDHash", string(hex.EncodeToString(r.CatalogUuidHash[:]))) 850 t.Log("\tIPFSAddr", string(r.IpfsAddress)) 851 t.Log("\tnacked", r.Nacked) 852 t.Log("\tapplication_parameter_name", string(r.ApplicationParameterName)) 853 } 854 } 855 856 func TestDeployFactory(t *testing.T) { 857 transactor, err := createTestTransactor(t) 858 859 client, err := createTestConnection(t) 860 defer client.Close() 861 862 addr, tx, factory, err := ethereum.DeployTaskFactory(transactor, client) 863 864 assert.Nil(t, err) 865 assert.NotNil(t, addr) 866 assert.NotNil(t, tx) 867 assert.NotNil(t, factory) 868 } 869 870 func TestFactoryCreateTask(t *testing.T) { 871 transactor, err := createTestTransactor(t) 872 873 client, err := createTestConnection(t) 874 defer client.Close() 875 876 addr, tx, factory, err := ethereum.DeployTaskFactory(transactor, client) 877 878 assert.Nil(t, err) 879 assert.NotNil(t, addr) 880 assert.NotNil(t, tx) 881 assert.NotNil(t, factory) 882 883 receipt, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 884 assert.Nil(t, err) 885 assert.NotNil(t, receipt) 886 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 887 888 tx, err = factory.CreateTask(transactor) 889 assert.Nil(t, err) 890 assert.NotNil(t, tx) 891 892 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 893 assert.Nil(t, err) 894 assert.NotNil(t, receipt) 895 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 896 897 tx, err = factory.CreateTask(transactor) 898 assert.Nil(t, err) 899 assert.NotNil(t, tx) 900 901 receipt, err = ethereum.PollForTransaction(client, tx.Hash(), time.Duration(20)*time.Second) 902 assert.Nil(t, err) 903 assert.NotNil(t, receipt) 904 assert.Equal(t, uint64(0x1), receipt.Status, "Transaction failed") 905 906 tasks, err := factory.GetTasks(nil) 907 assert.Nil(t, err) 908 assert.NotNil(t, tasks) 909 910 for i, task := range tasks { 911 t.Log("Task #", i) 912 t.Log("Task address ", task.Hex()) 913 bound_task, _ := ethereum.NewTask(task, client) 914 logTask(t, bound_task) 915 } 916 } 917 918 //TODO set max limit to polling in benchmarks 919 func TestBenchTaskDeploy(t *testing.T) { 920 if testing.Short() { 921 t.Skip("skipping benchmark tests") 922 } 923 924 transactor, _ := createTestTransactor(t) 925 926 client, _ := createTestConnection(t) 927 defer client.Close() 928 929 variants := []struct { 930 n int 931 expected bool 932 }{ 933 {1, true}, 934 {10, true}, 935 {100, true}, 936 {1000, true}, 937 } 938 939 for _, variant := range variants { 940 txs := make([]*types.Transaction, variant.n) 941 for i := 0; i < variant.n; i++ { 942 _, tx, _, _ := ethereum.DeployTask(transactor, client, transactor.From) 943 txs[i] = tx 944 t.Log("Deployed", tx.Hash().Hex()) 945 } 946 for _, tx := range txs { 947 _, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(70)*time.Second) 948 t.Log("Polled", tx.Hash().Hex(), err) 949 } 950 t.Log("Finished variant", variant) 951 } 952 } 953 954 func TestBenchTaskAddRequest(t *testing.T) { 955 if testing.Short() { 956 t.Skip("skipping benchmark tests") 957 } 958 959 transactor, _ := createTestTransactor(t) 960 961 client, _ := createTestConnection(t) 962 defer client.Close() 963 964 _, tx, task, _ := ethereum.DeployTask(transactor, client, transactor.From) 965 ethereum.PollForTransaction(client, tx.Hash(), time.Duration(550)*time.Second) 966 967 variants := []struct { 968 n int 969 expected bool 970 }{ 971 {1, true}, 972 {10, true}, 973 {100, true}, 974 {1000, true}, 975 } 976 977 for _, variant := range variants { 978 txs := make([]*types.Transaction, variant.n) 979 for i := 0; i < variant.n; i++ { 980 tx, _ = task.AddResourceRequest( 981 transactor, 982 common.HexToAddress("0x26b0A62f5370F4640E7e2E5f800ab1f79dd03f34"), 983 []byte("321"), 984 []byte("param_name_1"), 985 ) 986 txs[i] = tx 987 t.Log("Deployed", tx.Hash().Hex()) 988 } 989 for _, tx := range txs { 990 _, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(70)*time.Second) 991 t.Log("Polled", tx.Hash().Hex(), err) 992 } 993 t.Log("Finished variant", variant) 994 } 995 } 996 997 func TestBenchFactoryTaskCreate(t *testing.T) { 998 if testing.Short() { 999 t.Skip("skipping benchmark tests") 1000 } 1001 1002 transactor, _ := createTestTransactor(t) 1003 1004 client, _ := createTestConnection(t) 1005 defer client.Close() 1006 1007 _, tx, factory, _ := ethereum.DeployTaskFactory(transactor, client) 1008 1009 ethereum.PollForTransaction(client, tx.Hash(), time.Duration(550)*time.Second) 1010 1011 variants := []struct { 1012 n int 1013 expected bool 1014 }{ 1015 {1, true}, 1016 {10, true}, 1017 {100, true}, 1018 {1000, true}, 1019 } 1020 1021 for _, variant := range variants { 1022 txs := make([]*types.Transaction, variant.n) 1023 for i := 0; i < variant.n; i++ { 1024 tx, _ = factory.CreateTask(transactor) 1025 txs[i] = tx 1026 t.Log("Create called", tx.Hash().Hex()) 1027 } 1028 for _, tx := range txs { 1029 _, err := ethereum.PollForTransaction(client, tx.Hash(), time.Duration(70)*time.Second) 1030 t.Log("Polled", tx.Hash().Hex(), err) 1031 } 1032 t.Log("Finished variant", variant) 1033 } 1034 }