jahway603
/
hush3
forked from hush/hush3
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Grab changes from TonyL

metaverse
Jonathan "Duke" Leto 6 years ago
parent
c56b391b54
commit
ade19d82a5
1 changed files with 159 additions and 58 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 217
      qa/rpc-tests/cryptoconditions.py

217
qa/rpc-tests/cryptoconditions.py
View File

@ -5,7 +5,7 @@
from test_framework.test_framework import BitcoinTestFramework
from test_framework.authproxy import JSONRPCException
from test_framework.util import assert_equal, assert_raises, assert_greater_than, \
from test_framework.util import assert_equal, assert_greater_than, \
initialize_chain_clean, initialize_chain, start_nodes, start_node, connect_nodes_bi, \
stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds, rpc_port
@ -80,20 +80,20 @@ class CryptoConditionsTest (BitcoinTestFramework):
# no funds in the faucet yet
result = rpc.faucetget()
assert_equal(result['result'], 'error')
assert_error(result)
result = rpc.faucetinfo()
assert_equal(result['result'], 'success')
assert_success(result)
result = rpc.faucetfund("0")
assert_equal(result['result'], 'error')
assert_error(result)
result = rpc.faucetfund("-1")
assert_equal(result['result'], 'error')
assert_error(result)
# we need at least 1 + txfee to get
result = rpc.faucetfund("2")
assert_equal(result['result'], 'success')
assert_success(result)
assert result['hex'], "hex key found"
# broadcast the xtn
@ -110,23 +110,24 @@ class CryptoConditionsTest (BitcoinTestFramework):
assert_greater_than(balance, balance2)
result = rpc.faucetinfo()
assert_equal(result['result'], 'success')
assert_success(result)
assert_greater_than( result['funding'], 0 )
result = rpc.faucetget()
assert_equal(result['result'], 'success')
assert_success(result)
assert result['hex'], "hex key found"
# try to broadcast the xtn, but we will get 'faucet is only for brand new addresses'
assert_raises(JSONRPCException, rpc.sendrawtransaction, [ result['hex'] ])
# broadcast the xtn
result = rpc.sendrawtransaction(result['hex'])
txid = result[0]
assert txid, "found txid"
newaddr = rpc.getnewaddress()
assert newaddr, "got a new address"
result = rpc.validateaddress(newaddr)
newpubkey = result['pubkey']
assert newpubkey, "got a pubkey for new address"
# confirm above tx
rpc.generate(1)
result = rpc.getwalletinfo()
# TODO: stop this node, restart with diff pubkey
# we should have slightly more funds from the faucet now
assert_greater_than(result['balance'], balance2)
def run_dice_tests(self):
rpc = self.nodes[0]
@ -146,82 +147,184 @@ class CryptoConditionsTest (BitcoinTestFramework):
def run_token_tests(self):
rpc = self.nodes[0]
result = rpc.tokenaddress()
assert_equal(result['result'], 'success')
assert_success(result)
for x in ['AssetsCCaddress', 'myCCaddress', 'Assetsmarker', 'myaddress']:
assert_equal(result[x][0], 'R')
result = rpc.tokenaddress(self.pubkey)
assert_equal(result['result'], 'success')
assert_success(result)
for x in ['AssetsCCaddress', 'myCCaddress', 'Assetsmarker', 'myaddress', 'CCaddress']:
assert_equal(result[x][0], 'R')
assert_equal(result[x][0], 'R')
# there are no tokens created yet
result = rpc.tokenlist()
assert_equal(result, [])
result = rpc.tokencreate("DUKE", "1987.420", "duke")
assert_equal(result['result'], 'success')
self.send_and_mine(result['hex'])
assert_success(result)
tokenid = self.send_and_mine(result['hex'])
result = rpc.tokenlist()
tokenid = result[0]
assert(tokenid, "got tokenid")
assert_equal(result[0], tokenid)
# there are no token orders yet
result = rpc.tokenorders()
assert_equal(result, [])
# getting token balance for pubkey
result = rpc.tokenbalance(self.pubkey)
assert_success(result)
assert_equal(result['balance'], 0)
assert_equal(result['result'], 'success')
assert_equal(result['CCaddress'], 'RCRsm3VBXz8kKTsYaXKpy7pSEzrtNNQGJC')
tokenid = result['tokenid']
assert_equal(result['tokenid'], self.pubkey)
result = rpc.tokenorders(tokenid)
# get token balance for token with pubkey
result = rpc.tokenbalance(tokenid, self.pubkey)
assert_success(result)
assert_equal(result['balance'], 198742000000)
assert_equal(result['tokenid'], tokenid)
# get token balance for token without pubkey
result = rpc.tokenbalance(tokenid)
assert_success(result)
assert_equal(result['balance'], 198742000000)
assert_equal(result['tokenid'], tokenid)
# this is not a valid assetid
result = rpc.tokeninfo(self.pubkey)
assert_error(result)
# invalid numtokens
# check tokeninfo for valid token
result = rpc.tokeninfo(tokenid)
assert_success(result)
assert_equal(result['tokenid'], tokenid)
assert_equal(result['owner'], self.pubkey)
assert_equal(result['name'], "DUKE")
assert_equal(result['supply'], 198742000000)
assert_equal(result['description'], "duke")
# invalid numtokens ask
result = rpc.tokenask("-1", tokenid, "1")
assert_error(result)
# invalid numtokens
# invalid numtokens ask
result = rpc.tokenask("0", tokenid, "1")
assert_error(result)
# invalid price
# invalid price ask
result = rpc.tokenask("1", tokenid, "-1")
assert_error(result)
# invalid price
# invalid price ask
result = rpc.tokenask("1", tokenid, "0")
assert_error(result)
# invalid tokenid
# invalid tokenid ask
result = rpc.tokenask("100", "deadbeef", "1")
assert_error(result)
# valid
result = rpc.tokenask("100", tokenid, "7.77")
assert_success(result)
tokenaskhex = result['hex']
assert tokenaskhex, "got tokenask hexk"
tokenaskid = self.send_and_mine(result['hex'])
# valid ask
tokenask = rpc.tokenask("100", tokenid, "7.77")
tokenaskhex = tokenask['hex']
tokenaskid = self.send_and_mine(tokenask['hex'])
result = rpc.tokenorders()
order = result[0]
assert order, "found order"
# invalid fillunits
# invalid ask fillunits
result = rpc.tokenfillask(tokenid, tokenaskid, "0")
assert_error(result)
# invalid fillunits
# invalid ask fillunits
result = rpc.tokenfillask(tokenid, tokenaskid, "-777")
assert_error(result)
# should this pass or fail?
result = rpc.tokenfillask(tokenid, tokenaskid, "10")
#assert_success(result)
# valid ask fillunits
fillask = rpc.tokenfillask(tokenid, tokenaskid, "777")
result = self.send_and_mine(fillask['hex'])
txid = result[0]
assert txid, "found txid"
# should be no token orders
result = rpc.tokenorders()
assert_equal(result, [])
# checking ask cancellation
testorder = rpc.tokenask("100", tokenid, "7.77")
testorderid = self.send_and_mine(testorder['hex'])
cancel = rpc.tokencancelask(tokenid, testorderid)
self.send_and_mine(cancel["hex"])
result = rpc.tokenorders()
assert_equal(result, [])
# invalid numtokens bid (have to add status to CC code!)
result = rpc.tokenbid("-1", tokenid, "1")
assert_equal(result['error'], 'invalid parameter')
# invalid numtokens bid (have to add status to CC code!)
result = rpc.tokenbid("0", tokenid, "1")
assert_equal(result['error'], 'invalid parameter')
# invalid price bid (have to add status to CC code!)
result = rpc.tokenbid("1", tokenid, "-1")
assert_equal(result['error'], 'invalid parameter')
# invalid price bid (have to add status to CC code!)
result = rpc.tokenbid("1", tokenid, "0")
assert_equal(result['error'], 'invalid parameter')
# invalid tokenid bid (have to add status to CC code!)
result = rpc.tokenbid("100", "deadbeef", "1")
assert_equal(result['error'], 'invalid parameter')
# valid bid
tokenbid = rpc.tokenbid("100", tokenid, "10")
tokenbidhex = tokenbid['hex']
tokenbidid = self.send_and_mine(tokenbid['hex'])
result = rpc.tokenorders()
order = result[0]
assert order, "found order"
# invalid bid fillunits
result = rpc.tokenfillbid(tokenid, tokenbidid, "0")
assert_error(result)
# invalid bid fillunits
result = rpc.tokenfillbid(tokenid, tokenbidid, "-777")
assert_error(result)
# valid bid fillunits
fillbid = rpc.tokenfillbid(tokenid, tokenbidid, "1000")
result = self.send_and_mine(fillbid['hex'])
txid = result[0]
assert txid, "found txid"
# should be no token orders
result = rpc.tokenorders()
assert_equal(result, [])
# checking bid cancellation
testorder = rpc.tokenbid("100", tokenid, "7.77")
testorderid = self.send_and_mine(testorder['hex'])
cancel = rpc.tokencancelbid(tokenid, testorderid)
self.send_and_mine(cancel["hex"])
result = rpc.tokenorders()
assert_equal(result, [])
# invalid token transfer amount (have to add status to CC code!)
randompubkey = "021a559101e355c907d9c553671044d619769a6e71d624f68bfec7d0afa6bd6a96"
result = rpc.tokentransfer(tokenid,randompubkey,"0")
assert_equal(result['error'], 'invalid parameter')
# invalid token transfer amount (have to add status to CC code!)
result = rpc.tokentransfer(tokenid,randompubkey,"-1")
assert_equal(result['error'], 'invalid parameter')
# valid token transfer
sendtokens = rpc.tokentransfer(tokenid,randompubkey,"1")
self.send_and_mine(sendtokens["hex"])
result = rpc.tokenbalance(tokenid,randompubkey)
assert_equal(result["balance"], 1)
def run_rewards_tests(self):
rpc = self.nodes[0]
@ -239,19 +342,17 @@ class CryptoConditionsTest (BitcoinTestFramework):
# looking up non-existent reward should return error
result = rpc.rewardsinfo("none")
assert_equal(result['result'], 'error')
assert_error(result)
result = rpc.rewardscreatefunding("STUFF", "7777", "25", "0", "10", "10")
assert result['hex'], 'got raw xtn'
txid = rpc.sendrawtransaction(result['hex'])
assert txid, 'got txid'
result = rpc.rewardscreatefunding("THIS_IS_NOT_VALID777", "7777", "25", "0", "10", "10")
# confirm the above xtn
rpc.generate(1)
result = rpc.rewardsinfo(txid)
assert_equal(result['result'], 'success')
assert_success(result)
assert_equal(result['name'], 'STUFF')
assert_equal(result['APR'], "25.00000000")
assert_equal(result['minseconds'], 0)
@ -262,23 +363,23 @@ class CryptoConditionsTest (BitcoinTestFramework):
# funding amount must be positive
result = rpc.rewardsaddfunding("STUFF", txid, "0")
assert_equal(result['result'], 'error')
assert_error(result)
result = rpc.rewardsaddfunding("STUFF", txid, "555")
assert_equal(result['result'], 'success')
assert_success(result)
fundingtxid = result['hex']
assert fundingtxid, "got funding txid"
result = rpc.rewardslock("STUFF", fundingtxid, "7")
assert_equal(result['result'], 'error')
assert_error(result)
# the previous xtn has not been broadcasted yet
result = rpc.rewardsunlock("STUFF", fundingtxid)
assert_equal(result['result'], 'error')
assert_error(result)
# wrong plan name
result = rpc.rewardsunlock("SHTUFF", fundingtxid)
assert_equal(result['result'], 'error')
assert_error(result)
txid = rpc.sendrawtransaction(fundingtxid)
assert txid, 'got txid from sendrawtransaction'
@ -288,25 +389,25 @@ class CryptoConditionsTest (BitcoinTestFramework):
# amount must be positive
result = rpc.rewardslock("STUFF", fundingtxid, "-5")
assert_equal(result['result'], 'error')
assert_error(result)
# amount must be positive
result = rpc.rewardslock("STUFF", fundingtxid, "0")
assert_equal(result['result'], 'error')
assert_error(result)
# trying to lock less than the min amount is an error
result = rpc.rewardslock("STUFF", fundingtxid, "7")
assert_equal(result['result'], 'error')
assert_error(result)
# not working
#result = rpc.rewardslock("STUFF", fundingtxid, "10")
#assert_equal(result['result'], 'success')
#assert_success(result)
#locktxid = result['hex']
#assert locktxid, "got lock txid"
# locktxid has not been broadcast yet
#result = rpc.rewardsunlock("STUFF", locktxid)
#assert_equal(result['result'], 'error')
#assert_error(result)
# broadcast xtn
#txid = rpc.sendrawtransaction(locktxid)
@ -316,7 +417,7 @@ class CryptoConditionsTest (BitcoinTestFramework):
#rpc.generate(1)
#result = rpc.rewardsunlock("STUFF", locktxid)
#assert_equal(result['result'], 'error')
#assert_error(result)
def run_test (self):

Write Preview
Loading…
Cancel
Save