github.com/zignig/go-ipfs@v0.0.0-20141111235910-c9e5fdf55a52/unixfs/io/dagmodifier_test.go (about)

     1  package io
     2  
     3  import (
     4  	"fmt"
     5  	"io"
     6  	"io/ioutil"
     7  	"testing"
     8  
     9  	bs "github.com/jbenet/go-ipfs/blockservice"
    10  	imp "github.com/jbenet/go-ipfs/importer"
    11  	"github.com/jbenet/go-ipfs/importer/chunk"
    12  	mdag "github.com/jbenet/go-ipfs/merkledag"
    13  	ft "github.com/jbenet/go-ipfs/unixfs"
    14  	u "github.com/jbenet/go-ipfs/util"
    15  
    16  	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
    17  	logging "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-logging"
    18  )
    19  
    20  func getMockDagServ(t *testing.T) mdag.DAGService {
    21  	dstore := ds.NewMapDatastore()
    22  	bserv, err := bs.NewBlockService(dstore, nil)
    23  	if err != nil {
    24  		t.Fatal(err)
    25  	}
    26  	return mdag.NewDAGService(bserv)
    27  }
    28  
    29  func getNode(t *testing.T, dserv mdag.DAGService, size int64) ([]byte, *mdag.Node) {
    30  	in := io.LimitReader(u.NewTimeSeededRand(), size)
    31  	node, err := imp.BuildDagFromReader(in, dserv, nil, &chunk.SizeSplitter{500})
    32  	if err != nil {
    33  		t.Fatal(err)
    34  	}
    35  
    36  	dr, err := NewDagReader(node, dserv)
    37  	if err != nil {
    38  		t.Fatal(err)
    39  	}
    40  
    41  	b, err := ioutil.ReadAll(dr)
    42  	if err != nil {
    43  		t.Fatal(err)
    44  	}
    45  
    46  	return b, node
    47  }
    48  
    49  func testModWrite(t *testing.T, beg, size uint64, orig []byte, dm *DagModifier) []byte {
    50  	newdata := make([]byte, size)
    51  	r := u.NewTimeSeededRand()
    52  	r.Read(newdata)
    53  
    54  	if size+beg > uint64(len(orig)) {
    55  		orig = append(orig, make([]byte, (size+beg)-uint64(len(orig)))...)
    56  	}
    57  	copy(orig[beg:], newdata)
    58  
    59  	nmod, err := dm.WriteAt(newdata, uint64(beg))
    60  	if err != nil {
    61  		t.Fatal(err)
    62  	}
    63  
    64  	if nmod != int(size) {
    65  		t.Fatalf("Mod length not correct! %d != %d", nmod, size)
    66  	}
    67  
    68  	nd, err := dm.GetNode()
    69  	if err != nil {
    70  		t.Fatal(err)
    71  	}
    72  
    73  	rd, err := NewDagReader(nd, dm.dagserv)
    74  	if err != nil {
    75  		t.Fatal(err)
    76  	}
    77  
    78  	after, err := ioutil.ReadAll(rd)
    79  	if err != nil {
    80  		t.Fatal(err)
    81  	}
    82  
    83  	err = arrComp(after, orig)
    84  	if err != nil {
    85  		t.Fatal(err)
    86  	}
    87  	return orig
    88  }
    89  
    90  func TestDagModifierBasic(t *testing.T) {
    91  	logging.SetLevel(logging.CRITICAL, "blockservice")
    92  	logging.SetLevel(logging.CRITICAL, "merkledag")
    93  	dserv := getMockDagServ(t)
    94  	b, n := getNode(t, dserv, 50000)
    95  
    96  	dagmod, err := NewDagModifier(n, dserv, &chunk.SizeSplitter{Size: 512})
    97  	if err != nil {
    98  		t.Fatal(err)
    99  	}
   100  
   101  	// Within zero block
   102  	beg := uint64(15)
   103  	length := uint64(60)
   104  
   105  	t.Log("Testing mod within zero block")
   106  	b = testModWrite(t, beg, length, b, dagmod)
   107  
   108  	// Within bounds of existing file
   109  	beg = 1000
   110  	length = 4000
   111  	t.Log("Testing mod within bounds of existing file.")
   112  	b = testModWrite(t, beg, length, b, dagmod)
   113  
   114  	// Extend bounds
   115  	beg = 49500
   116  	length = 4000
   117  
   118  	t.Log("Testing mod that extends file.")
   119  	b = testModWrite(t, beg, length, b, dagmod)
   120  
   121  	// "Append"
   122  	beg = uint64(len(b))
   123  	length = 3000
   124  	b = testModWrite(t, beg, length, b, dagmod)
   125  
   126  	// Verify reported length
   127  	node, err := dagmod.GetNode()
   128  	if err != nil {
   129  		t.Fatal(err)
   130  	}
   131  
   132  	size, err := ft.DataSize(node.Data)
   133  	if err != nil {
   134  		t.Fatal(err)
   135  	}
   136  
   137  	expected := uint64(50000 + 3500 + 3000)
   138  	if size != expected {
   139  		t.Fatalf("Final reported size is incorrect [%d != %d]", size, expected)
   140  	}
   141  }
   142  
   143  func TestMultiWrite(t *testing.T) {
   144  	dserv := getMockDagServ(t)
   145  	_, n := getNode(t, dserv, 0)
   146  
   147  	dagmod, err := NewDagModifier(n, dserv, &chunk.SizeSplitter{Size: 512})
   148  	if err != nil {
   149  		t.Fatal(err)
   150  	}
   151  
   152  	data := make([]byte, 4000)
   153  	u.NewTimeSeededRand().Read(data)
   154  
   155  	for i := 0; i < len(data); i++ {
   156  		n, err := dagmod.WriteAt(data[i:i+1], uint64(i))
   157  		if err != nil {
   158  			t.Fatal(err)
   159  		}
   160  		if n != 1 {
   161  			t.Fatal("Somehow wrote the wrong number of bytes! (n != 1)")
   162  		}
   163  	}
   164  	nd, err := dagmod.GetNode()
   165  	if err != nil {
   166  		t.Fatal(err)
   167  	}
   168  
   169  	read, err := NewDagReader(nd, dserv)
   170  	if err != nil {
   171  		t.Fatal(err)
   172  	}
   173  	rbuf, err := ioutil.ReadAll(read)
   174  	if err != nil {
   175  		t.Fatal(err)
   176  	}
   177  
   178  	err = arrComp(rbuf, data)
   179  	if err != nil {
   180  		t.Fatal(err)
   181  	}
   182  }
   183  
   184  func TestMultiWriteCoal(t *testing.T) {
   185  	dserv := getMockDagServ(t)
   186  	_, n := getNode(t, dserv, 0)
   187  
   188  	dagmod, err := NewDagModifier(n, dserv, &chunk.SizeSplitter{Size: 512})
   189  	if err != nil {
   190  		t.Fatal(err)
   191  	}
   192  
   193  	data := make([]byte, 4000)
   194  	u.NewTimeSeededRand().Read(data)
   195  
   196  	for i := 0; i < len(data); i++ {
   197  		n, err := dagmod.WriteAt(data[:i+1], 0)
   198  		if err != nil {
   199  			t.Fatal(err)
   200  		}
   201  		if n != i+1 {
   202  			t.Fatal("Somehow wrote the wrong number of bytes! (n != 1)")
   203  		}
   204  	}
   205  	nd, err := dagmod.GetNode()
   206  	if err != nil {
   207  		t.Fatal(err)
   208  	}
   209  
   210  	read, err := NewDagReader(nd, dserv)
   211  	if err != nil {
   212  		t.Fatal(err)
   213  	}
   214  	rbuf, err := ioutil.ReadAll(read)
   215  	if err != nil {
   216  		t.Fatal(err)
   217  	}
   218  
   219  	err = arrComp(rbuf, data)
   220  	if err != nil {
   221  		t.Fatal(err)
   222  	}
   223  }
   224  
   225  func arrComp(a, b []byte) error {
   226  	if len(a) != len(b) {
   227  		return fmt.Errorf("Arrays differ in length. %d != %d", len(a), len(b))
   228  	}
   229  	for i, v := range a {
   230  		if v != b[i] {
   231  			return fmt.Errorf("Arrays differ at index: %d", i)
   232  		}
   233  	}
   234  	return nil
   235  }