func TestReadMultiChunkSinglePass(t *testing.T) {
	b := new(bytes.Buffer)
	c1 := &chunk.Chunk{
		Header: &chunk.Header{
			BasicHeader:       chunk.BasicHeader{0, 18},
			MessageHeader:     chunk.MessageHeader{0, 1234, false, 8, 2, 3},
			ExtendedTimestamp: chunk.ExtendedTimestamp{},
		},
		Data: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07},
	}
	c2 := &chunk.Chunk{
		Header: &chunk.Header{
			BasicHeader:       chunk.BasicHeader{0, 19},
			MessageHeader:     chunk.MessageHeader{0, 1234, false, 8, 2, 3},
			ExtendedTimestamp: chunk.ExtendedTimestamp{},
		},
		Data: []byte{0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f},
	}

	chunk.NewWriter(b, chunk.DefaultReadSize).Write(c1)
	chunk.NewWriter(b, chunk.DefaultReadSize).Write(c2)

	r := NewReader(b)
	go r.Recv()

	r1 := <-r.Chunks()
	r2 := <-r.Chunks()

	assert.Equal(t, 0, len(r.Errs()))
	assert.Equal(t, c1, r1)
	assert.Equal(t, c2, r2)
}
func TestMultipleWrites(t *testing.T) {
	buf := new(bytes.Buffer)
	c := &chunk.Chunk{
		Header: &chunk.Header{
			BasicHeader:       chunk.BasicHeader{0, 18},
			MessageHeader:     chunk.MessageHeader{0, 1234, false, 8, 2, 3},
			ExtendedTimestamp: chunk.ExtendedTimestamp{},
		},
		Data: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07},
	}

	err := chunk.NewWriter(buf, 4).Write(c)

	assert.Nil(t, err)

	expected := new(bytes.Buffer)
	(&chunk.BasicHeader{0, 18}).Write(expected)
	(&chunk.MessageHeader{0, 1234, false, 8, 2, 3}).Write(expected)
	expected.Write([]byte{0x00, 0x01, 0x02, 0x03})
	expected.Write([]byte{byte((3 << 6) | 18&63)})
	expected.Write([]byte{0x04, 0x05, 0x06, 0x07})

	assert.True(t, bytes.Equal(expected.Bytes(), buf.Bytes()),
		fmt.Sprintf("test: slice should be equal (%v, %v)", expected.Bytes(),
			buf.Bytes()))
}
Example #3
0
func TestStreamSendsOnStatusUpdates(t *testing.T) {
	buf := new(bytes.Buffer)
	writer := chunk.NewWriter(buf, chunk.DefaultReadSize)

	chunks := make(chan *chunk.Chunk)
	s := New(chunks, writer)

	go s.Listen()

	err := s.WriteStatus(NewStatus())

	assert.Nil(t, err)
	assert.NotEmpty(t, buf.Bytes())
}
Example #4
0
func newStreamWithChunk(streamId uint32, chunks ...*chunk.Chunk) chunk.Stream {
	buf := new(bytes.Buffer)
	for _, c := range chunks {
		chunk.NewWriter(buf, chunk.DefaultReadSize).Write(c)
	}

	parser := chunk.NewParser(chunk.NewReader(
		buf, chunk.DefaultReadSize, chunk.NoopNormalizer,
	))
	go parser.Recv()

	st, _ := parser.Stream(streamId)
	return st
}
Example #5
0
func TestChunkingErrorsArePropogated(t *testing.T) {
	out := new(CreateStreamResponse)
	chunker := new(MockChunker)
	chunker.On("Chunk", out).Return(nil, errors.New("foo")).Once()

	nc := NewNetConnection(
		make(chan *chunk.Chunk),
		chunk.NewWriter(new(bytes.Buffer), chunk.DefaultReadSize))
	nc.chunker = chunker

	go nc.Listen()

	err := nc.Send(out)

	assert.Equal(t, "foo", err.Error())
}
func TestReadSingleChunkMultiPass(t *testing.T) {
	b := new(bytes.Buffer)
	c := &chunk.Chunk{
		Header: &chunk.Header{
			BasicHeader:       chunk.BasicHeader{0, 18},
			MessageHeader:     chunk.MessageHeader{0, 1234, false, 8, 2, 3},
			ExtendedTimestamp: chunk.ExtendedTimestamp{},
		},
		Data: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07},
	}

	chunk.NewWriter(b, 4).Write(c)

	r := chunk.NewReader(b, 4, chunk.NoopNormalizer)
	go r.Recv()

	read := <-r.Chunks()

	assert.Equal(t, 0, len(r.Errs()))
	assert.Equal(t, c, read)
}
Example #7
0
func TestWritingAControlChunksIt(t *testing.T) {
	ctrl := new(control.Acknowledgement)

	chunker := &MockChunker{}
	chunker.On("Chunk", ctrl).Return(&chunk.Chunk{
		Header: &chunk.Header{
			BasicHeader:   chunk.BasicHeader{0, 2},
			MessageHeader: chunk.MessageHeader{},
		},
	}, nil)

	stream := control.NewStream(
		newStreamWithChunk(2), chunk.NewWriter(ioutil.Discard,
			chunk.DefaultReadSize), nil, chunker,
	)

	err := stream.Send(ctrl)

	assert.Nil(t, err)
	chunker.AssertExpectations(t)
}
Example #8
0
func TestSendablesAreWrittenToChunkStream(t *testing.T) {
	buf := new(bytes.Buffer)

	nc := NewNetConnection(
		make(chan *chunk.Chunk),
		chunk.NewWriter(buf, chunk.DefaultReadSize))
	go nc.Listen()

	err := nc.Send(&CreateStreamResponse{
		TransactionId: 1,
	})

	assert.Nil(t, err)
	assert.Equal(t, []byte{
		0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x14, 0x00, 0x00,
		0x00, 0x00, 0x02, 0x00, 0x07, 0x5f, 0x72, 0x65, 0x73, 0x75,
		0x6c, 0x74, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00,
	}, buf.Bytes())

}
Example #9
0
func TestRecvWritesToChunkWriter(t *testing.T) {
	buf := new(bytes.Buffer)
	writer := chunk.NewWriter(buf, 4096)

	ch := &chunk.Chunk{
		Header: new(chunk.Header),
		Data:   []byte{0x0, 0x1, 0x2, 0x3},
	}

	d := new(MockData)
	d.On("Marshal").Return(ch, nil).Once()

	s := data.NewStream(make(chan *chunk.Chunk), writer)
	go s.Recv()

	err := s.Write(d)

	assert.Equal(t, []byte{
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
	}, buf.Bytes())
	assert.Nil(t, err)
}
Example #10
0
// New instantiates and returns a pointer to a new instance of type Client. The
// client is initialized with the given connection.
func New(conn io.ReadWriter) *Client {
	chunkWriter := chunk.NewWriter(conn, 4096)
	chunks := chunk.NewParser(chunk.NewReader(
		conn, chunk.DefaultReadSize, chunk.NewNormalizer(),
	))

	controlChunks, _ := chunks.Stream(2)
	netChunks, _ := chunks.Stream(3, 4, 5, 8)

	return &Client{
		chunks: chunks,

		controlStream: control.NewStream(
			controlChunks,
			chunkWriter,
			control.NewParser(),
			control.NewChunker(),
		),

		cmdManager: cmd.New(netChunks, chunkWriter),

		Conn: conn,
	}
}
func TestWriterConstruction(t *testing.T) {
	w := chunk.NewWriter(new(bytes.Buffer), chunk.DefaultReadSize)

	assert.IsType(t, &chunk.DefaultWriter{}, w)
}