p2pool/test/test_p2p.py

   1 import random
   2
   3 from twisted.internet import defer, endpoints, protocol, reactor
   4 from twisted.trial import unittest
   5
   6 from p2pool import networks, p2p
   7 from p2pool.bitcoin import data as bitcoin_data
   8 from p2pool.util import deferral
   9
  10
  11 class Test(unittest.TestCase):
  12     @defer.inlineCallbacks
  13     def test_sharereq(self):
  14         class MyNode(p2p.Node):
  15             def __init__(self, df):
  16                 p2p.Node.__init__(self, lambda: None, 29333, networks.nets['bitcoin'], {}, set([('127.0.0.1', 9333)]), 0, 0, 0, 0)
  17
  18                 self.df = df
  19
  20             def handle_share_hashes(self, hashes, peer):
  21                 peer.get_shares(
  22                     hashes=[hashes[0]],
  23                     parents=5,
  24                     stops=[],
  25                 ).chainDeferred(self.df)
  26
  27         df = defer.Deferred()
  28         n = MyNode(df)
  29         n.start()
  30         try:
  31             yield df
  32         finally:
  33             yield n.stop()
  34
  35     @defer.inlineCallbacks
  36     def test_tx_limit(self):
  37         class MyNode(p2p.Node):
  38             def __init__(self, df):
  39                 p2p.Node.__init__(self, lambda: None, 29333, networks.nets['litecoin_testnet'], {}, set([('127.0.0.1', 19338)]), 0, 0, 0, 0)
  40
  41                 self.df = df
  42                 self.sent_time = 0
  43
  44             @defer.inlineCallbacks
  45             def got_conn(self, conn):
  46                 p2p.Node.got_conn(self, conn)
  47                 huge_tx = dict(
  48                     version=0,
  49                     tx_ins=[],
  50                     tx_outs=[dict(
  51                         value=0,
  52                         script='x'*900000,
  53                     )],
  54                     lock_time=0,
  55                 )
  56                 new_mining_txs = dict(self.mining_txs_var.value)
  57                 new_mining_txs[bitcoin_data.hash256(bitcoin_data.tx_type.pack(huge_tx))] = huge_tx
  58                 self.mining_txs_var.set(new_mining_txs)
  59
  60                 yield deferral.sleep(1)
  61
  62                 huge_tx = dict(
  63                     version=0,
  64                     tx_ins=[],
  65                     tx_outs=[dict(
  66                         value=0,
  67                         script='x'*900000,
  68                     )],
  69                     lock_time=1,
  70                 )
  71                 new_mining_txs = dict(self.mining_txs_var.value)
  72                 new_mining_txs[bitcoin_data.hash256(bitcoin_data.tx_type.pack(huge_tx))] = huge_tx
  73                 self.mining_txs_var.set(new_mining_txs)
  74                 self.sent_time = reactor.seconds()
  75
  76
  77             def lost_conn(self, conn, reason):
  78                 self.df.callback(None)
  79
  80         df = defer.Deferred()
  81         n = MyNode(df)
  82         n.start()
  83         yield df
  84         if not (n.sent_time <= reactor.seconds() <= n.sent_time + 1):
  85             raise ValueError('node did not disconnect within 1 seconds of receiving too much tx data')
  86         yield n.stop()