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  }