src/allmydata/test/test_encode.py

   1 #! /usr/bin/env python
   2
   3 from twisted.trial import unittest
   4 from twisted.internet import defer
   5 from allmydata import encode_new
   6 from cStringIO import StringIO
   7
   8 class MyEncoder(encode_new.Encoder):
   9     def send(self, share_num, methname, *args, **kwargs):
  10         if False and share_num < 10:
  11             print "send[%d].%s()" % (share_num, methname)
  12             if methname == "put_share_hashes":
  13                 print " ", [i for i,h in args[0]]
  14         return defer.succeed(None)
  15
  16 class Encode(unittest.TestCase):
  17     def test_1(self):
  18         e = MyEncoder()
  19         data = StringIO("some data to encode\n")
  20         e.setup(data)
  21         d = e.start()
  22         return d
  23
  24 class FakePeer:
  25     def __init__(self):
  26         self.blocks = {}
  27         self.blockhashes = None
  28         self.sharehashes = None
  29         self.closed = False
  30
  31     def callRemote(self, methname, *args, **kwargs):
  32         def _call():
  33             meth = getattr(self, methname)
  34             return meth(*args, **kwargs)
  35         return defer.maybeDeferred(_call)
  36
  37     def put_block(self, segmentnum, data):
  38         assert not self.closed
  39         assert segmentnum not in self.blocks
  40         self.blocks[segmentnum] = data
  41
  42     def put_block_hashes(self, blockhashes):
  43         assert not self.closed
  44         assert self.blockhashes is None
  45         self.blockhashes = blockhashes
  46
  47     def put_share_hashes(self, sharehashes):
  48         assert not self.closed
  49         assert self.sharehashes is None
  50         self.sharehashes = sharehashes
  51
  52     def close(self):
  53         assert not self.closed
  54         self.closed = True
  55
  56
  57 class UpDown(unittest.TestCase):
  58     def test_send(self):
  59         e = encode_new.Encoder()
  60         data = "happy happy joy joy" * 4
  61         e.setup(StringIO(data))
  62         NUM_SHARES = 100
  63         assert e.num_shares == NUM_SHARES # else we'll be completely confused
  64         e.segment_size = 25 # force use of multiple segments
  65         NUM_SEGMENTS = 4
  66         assert (NUM_SEGMENTS-1)*e.segment_size < len(data) <= NUM_SEGMENTS*e.segment_size
  67         shareholders = {}
  68         all_shareholders = []
  69         for shnum in range(NUM_SHARES):
  70             peer = FakePeer()
  71             shareholders[shnum] = peer
  72             all_shareholders.append(peer)
  73         e.set_shareholders(shareholders)
  74         d = e.start()
  75         def _check(roothash):
  76             self.failUnless(isinstance(roothash, str))
  77             self.failUnlessEqual(len(roothash), 32)
  78             for i,peer in enumerate(all_shareholders):
  79                 self.failUnless(peer.closed)
  80                 self.failUnlessEqual(len(peer.blocks), NUM_SEGMENTS)
  81                 #self.failUnlessEqual(len(peer.blockhashes), NUM_SEGMENTS)
  82                 # that isn't true: each peer gets a full tree, so it's more
  83                 # like 2n-1 but with rounding to a power of two
  84                 for h in peer.blockhashes:
  85                     self.failUnlessEqual(len(h), 32)
  86                 #self.failUnlessEqual(len(peer.sharehashes), NUM_SHARES)
  87                 # that isn't true: each peer only gets the chain they need
  88                 for (hashnum, h) in peer.sharehashes:
  89                     self.failUnless(isinstance(hashnum, int))
  90                     self.failUnlessEqual(len(h), 32)
  91         d.addCallback(_check)
  92
  93         return d