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['bitcoin'], {}, set([('127.0.0.1', 9333)]), 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
  48                 yield deferral.sleep(.5)
  49
  50                 new_mining_txs = dict(self.mining_txs_var.value)
  51                 for i in xrange(3):
  52                     huge_tx = dict(
  53                         version=0,
  54                         tx_ins=[],
  55                         tx_outs=[dict(
  56                             value=0,
  57                             script='x'*900000,
  58                         )],
  59                         lock_time=i,
  60                     )
  61                     new_mining_txs[bitcoin_data.hash256(bitcoin_data.tx_type.pack(huge_tx))] = huge_tx
  62                 self.mining_txs_var.set(new_mining_txs)
  63
  64                 self.sent_time = reactor.seconds()
  65
  66             def lost_conn(self, conn, reason):
  67                 self.df.callback(None)
  68         try:
  69             p2p.Protocol.max_remembered_txs_size *= 10
  70
  71             df = defer.Deferred()
  72             n = MyNode(df)
  73             n.start()
  74             yield df
  75             if not (n.sent_time <= reactor.seconds() <= n.sent_time + 1):
  76                 raise ValueError('node did not disconnect within 1 seconds of receiving too much tx data')
  77             yield n.stop()
  78         finally:
  79             p2p.Protocol.max_remembered_txs_size //= 10