Butler stream servers can generate client address.

logdog/client/butler/streamserver/base_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package streamserver
 
 import (
         "bytes"
         "errors"
         "fmt"
         "io/ioutil"
         "net"
         "testing"
         "time"
 
+        "github.com/luci/luci-go/common/clock/clockflag"
+        "github.com/luci/luci-go/common/clock/testclock"
+        "github.com/luci/luci-go/logdog/client/butlerlib/streamclient"
         "github.com/luci/luci-go/logdog/client/butlerlib/streamproto"
+
+        "golang.org/x/net/context"
+
         . "github.com/smartystreets/goconvey/convey"
-        "golang.org/x/net/context"
 )
 
 type testAddr string
 
 func (a testAddr) Network() string { return string(a) }
 func (a testAddr) String() string  { return fmt.Sprintf("test(%s)", a.Network()) }
 
 type testListener struct {
         err   error
         connC chan *testListenerConn
@@ skipping 69 matching lines @@
         t.Parallel()
 
         Convey(`A stream server using a testing Listener`, t, func() {
                 hb := handshakeBuilder{
                         magic: streamproto.ProtocolFrameHeaderMagic,
                 }
 
                 var tl *testListener
                 s := &listenerStreamServer{
                         Context: context.Background(),
-                        gen: func() (net.Listener, error) {
+                        gen: func() (net.Listener, string, error) {
                                 if tl != nil {
                                         panic("gen called more than once")
                                 }
                                 tl = newTestListener()
-                                return tl, nil
+                                return tl, "test", nil
                         },
                 }
 
                 Convey(`Will panic if closed without listening.`, func() {
                         So(func() { s.Close() }, ShouldPanic)
                 })
 
                 Convey(`Will fail to Listen if the Listener could not be created.`, func() {
-                        s.gen = func() (net.Listener, error) {
-                                return nil, errors.New("test error")
+                        s.gen = func() (net.Listener, string, error) {
+                                return nil, "", errors.New("test error")
                         }
                         So(s.Listen(), ShouldNotBeNil)
                 })
 
                 Convey(`Can Listen for connections.`, func() {
                         shouldClose := true
                         So(s.Listen(), ShouldBeNil)
                         defer func() {
                                 if shouldClose {
                                         s.Close()
@@ skipping 87 matching lines @@
                                 tl.connect(tc)
                                 s.Close()
                                 shouldClose = false
 
                                 So(<-s.discardC, ShouldNotBeNil)
                         })
 
                 })
         })
 }
+
+// testClientServer tests to ensure that a client can create streams with a
+// server.
+//
+// svr must be in listening state when this is called.
+func testClientServer(t *testing.T, svr StreamServer, client streamclient.Client) {
+        flags := streamproto.Flags{
+                Name:      "foo/bar",
+                Timestamp: clockflag.Time(testclock.TestTimeLocal),
+        }
+        data := []byte("ohaithere")
+
+        clientDoneC := make(chan error)
+        go func() {
+                var err error
+                defer func() {
+                        clientDoneC <- err
+                }()
+
+                var stream streamclient.Stream
+                if stream, err = client.NewStream(flags); err != nil {
+                        return
+                }
+                defer func() {
+                        if closeErr := stream.Close(); closeErr != nil && err == nil {
+                                err = closeErr
+                        }
+                }()
+
+                if _, err = stream.Write(data); err != nil {
+                        return
+                }
+        }()
+
+        rc, props := svr.Next()
+        defer rc.Close()
+
+        So(props, ShouldResemble, flags.Properties())
+
+        var buf bytes.Buffer
+        _, err := buf.ReadFrom(rc)
+        So(err, ShouldBeNil)
+        So(buf.Bytes(), ShouldResemble, data)
+
+        So(<-clientDoneC, ShouldBeNil)
+}