Merge branch '10700-dispatch'

[arvados.git] / sdk / go / keepclient / collectionreader_test.go

diff --git a/sdk/go/keepclient/collectionreader_test.go b/sdk/go/keepclient/collectionreader_test.go
index 2cc23738855dfeab3cd8ab2ef33cb27055a35fa1..6f49c590fdca4c1b1b4776562e3f5b78ee1bbe54 100644 (file)
--- a/sdk/go/keepclient/collectionreader_test.go
+++ b/sdk/go/keepclient/collectionreader_test.go
@@ -19,7 +19,7 @@ import (
 var _ = check.Suite(&CollectionReaderUnit{})
 
 type CollectionReaderUnit struct {
-       arv     arvadosclient.ArvadosClient
+       arv     *arvadosclient.ArvadosClient
        kc      *KeepClient
        handler SuccessHandler
 }
@@ -30,7 +30,7 @@ func (s *CollectionReaderUnit) SetUpTest(c *check.C) {
        c.Assert(err, check.IsNil)
        s.arv.ApiToken = arvadostest.ActiveToken
 
-       s.kc, err = MakeKeepClient(&s.arv)
+       s.kc, err = MakeKeepClient(s.arv)
        c.Assert(err, check.IsNil)
 
        s.handler = SuccessHandler{
@@ -121,6 +121,7 @@ func (s *CollectionReaderUnit) TestCollectionReaderContent(c *check.C) {
                {mt: mt, f: "segmented/frob", want: "frob"},
                {mt: mt, f: "segmented/oof", want: "oof"},
        } {
+               c.Logf("%#v", testCase)
                rdr, err := s.kc.CollectionFileReader(map[string]interface{}{"manifest_text": testCase.mt}, testCase.f)
                switch want := testCase.want.(type) {
                case error:
@@ -136,6 +137,23 @@ func (s *CollectionReaderUnit) TestCollectionReaderContent(c *check.C) {
                                c.Check(n, check.Equals, 0)
                                c.Check(err, check.Equals, io.EOF)
                        }
+
+                       for a := len(want) - 2; a >= 0; a-- {
+                               for b := a + 1; b <= len(want); b++ {
+                                       offset, err := rdr.Seek(int64(a), io.SeekStart)
+                                       c.Logf("...a=%d, b=%d", a, b)
+                                       c.Check(err, check.IsNil)
+                                       c.Check(offset, check.Equals, int64(a))
+                                       buf := make([]byte, b-a)
+                                       n, err := io.ReadFull(rdr, buf)
+                                       c.Check(n, check.Equals, b-a)
+                                       c.Check(string(buf), check.Equals, want[a:b])
+                               }
+                       }
+                       offset, err := rdr.Seek(-1, io.SeekStart)
+                       c.Check(err, check.NotNil)
+                       c.Check(offset, check.Equals, int64(len(want)))
+
                        c.Check(rdr.Close(), check.Equals, nil)
                }
        }
@@ -168,13 +186,16 @@ func (s *CollectionReaderUnit) TestCollectionReaderManyBlocks(c *check.C) {
 }
 
 func (s *CollectionReaderUnit) TestCollectionReaderCloseEarly(c *check.C) {
+       s.kc.BlockCache = &BlockCache{}
        s.kc.PutB([]byte("foo"))
+       s.kc.PutB([]byte("bar"))
+       s.kc.PutB([]byte("baz"))
 
        mt := ". "
-       for i := 0; i < 1000; i++ {
-               mt += "acbd18db4cc2f85cedef654fccc4a4d8+3 "
+       for i := 0; i < 300; i++ {
+               mt += "acbd18db4cc2f85cedef654fccc4a4d8+3 37b51d194a7513e45b56f6524f2d51f2+3 73feffa4b7f6bb68e44cf984c85f6e88+3 "
        }
-       mt += "0:3000:foo1000.txt\n"
+       mt += "0:2700:foo900.txt\n"
 
        // Grab the stub server's lock, ensuring our cfReader doesn't
        // get anything back from its first call to kc.Get() before we
@@ -182,17 +203,16 @@ func (s *CollectionReaderUnit) TestCollectionReaderCloseEarly(c *check.C) {
        s.handler.lock <- struct{}{}
        opsBeforeRead := *s.handler.ops
 
-       rdr, err := s.kc.CollectionFileReader(map[string]interface{}{"manifest_text": mt}, "foo1000.txt")
+       rdr, err := s.kc.CollectionFileReader(map[string]interface{}{"manifest_text": mt}, "foo900.txt")
        c.Assert(err, check.IsNil)
 
        firstReadDone := make(chan struct{})
        go func() {
-               rdr.Read(make([]byte, 6))
-               firstReadDone <- struct{}{}
+               n, err := rdr.Read(make([]byte, 3))
+               c.Check(n, check.Equals, 3)
+               c.Check(err, check.IsNil)
+               close(firstReadDone)
        }()
-       err = rdr.Close()
-       c.Assert(err, check.IsNil)
-       c.Assert(rdr.(*cfReader).Error(), check.IsNil)
 
        // Release the stub server's lock. The first GET operation will proceed.
        <-s.handler.lock
@@ -201,13 +221,11 @@ func (s *CollectionReaderUnit) TestCollectionReaderCloseEarly(c *check.C) {
        // received from the first GET.
        <-firstReadDone
 
-       // doGet() should close toRead before sending any more bufs to it.
-       if what, ok := <-rdr.(*cfReader).toRead; ok {
-               c.Errorf("Got %q, expected toRead to be closed", what)
-       }
+       err = rdr.Close()
+       c.Check(err, check.IsNil)
 
        // Stub should have handled exactly one GET request.
-       c.Assert(*s.handler.ops, check.Equals, opsBeforeRead+1)
+       c.Check(*s.handler.ops, check.Equals, opsBeforeRead+1)
 }
 
 func (s *CollectionReaderUnit) TestCollectionReaderDataError(c *check.C) {
@@ -220,5 +238,5 @@ func (s *CollectionReaderUnit) TestCollectionReaderDataError(c *check.C) {
                c.Check(err, check.NotNil)
                c.Check(err, check.Not(check.Equals), io.EOF)
        }
-       c.Check(rdr.Close(), check.NotNil)
+       c.Check(rdr.Close(), check.IsNil)
 }