public void ReadByteShouldStartReadingAtBeginningOfFile()
{
var data = GenerateRandom(5, _random);
SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
SftpSessionMock.InSequence(MockSequence).Setup(p => p.RequestRead(_handle, 0UL, _readBufferSize))
.Returns(data);
var actual = _target.ReadByte();
Assert.AreEqual(data[0], actual);
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(1));
SftpSessionMock.Verify(p => p.RequestRead(_handle, 0UL, _readBufferSize), Times.Once);
}
public void DisposeShouldCloseHandleAndCompleteImmediately()
{
SftpSessionMock.InSequence(_seq).Setup(p => p.BeginClose(_handle, null, null)).Returns(_closeAsyncResult);
SftpSessionMock.InSequence(_seq).Setup(p => p.EndClose(_closeAsyncResult));
var stopwatch = Stopwatch.StartNew();
_reader.Dispose();
stopwatch.Stop();
Assert.IsTrue(stopwatch.ElapsedMilliseconds < 200, "Dispose took too long to complete: " + stopwatch.ElapsedMilliseconds);
SftpSessionMock.Verify(p => p.BeginClose(_handle, null, null), Times.Once);
SftpSessionMock.Verify(p => p.EndClose(_closeAsyncResult), Times.Once);
}
public void SubsequentReadShouldReadAgainFromCurrentPositionFromServerAndNotUpdatePositionWhenServerReturnsZeroBytes()
{
SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.RequestRead(_handle, (ulong)_actual, _readBufferSize))
.Returns(Array <byte> .Empty);
SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
_target.Read(new byte[10], 0, 10);
Assert.AreEqual(_actual, _target.Position);
SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)_actual, _readBufferSize), Times.Once);
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(3));
}
public void WriteByteShouldThrowNotSupportedException()
{
SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
try
{
_target.WriteByte(0x0a);
}
catch (NotSupportedException ex)
{
Assert.IsNull(ex.InnerException);
Assert.AreEqual("Write not supported.", ex.Message);
}
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(1));
}
public void SubsequentReadShouldReadAgainFromCurrentPositionFromServerAndReturnZeroWhenServerReturnsZeroBytes()
{
SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.RequestRead(_handle, (ulong)_actual, _readBufferSize))
.Returns(Array <byte> .Empty);
var buffer = _originalBuffer.Copy();
var actual = _target.Read(buffer, 0, buffer.Length);
Assert.AreEqual(0, actual);
Assert.IsTrue(_originalBuffer.IsEqualTo(buffer));
SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)_actual, _readBufferSize), Times.Once);
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
}
public void SubsequentReadShouldReturnAllRemaningBytesFromReadBufferAndReadAgainWhenCountIsGreaterThanNumberOfRemainingBytesAndNewReadReturnsZeroBytes()
{
SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
SftpSessionMock.InSequence(MockSequence).Setup(p => p.RequestRead(_handle, (ulong)(_serverData.Length), _readBufferSize)).Returns(Array <byte> .Empty);
var buffer = new byte[_numberOfBytesToWriteToReadBuffer + 1];
var actual = _target.Read(buffer, 0, buffer.Length);
Assert.AreEqual(_numberOfBytesToWriteToReadBuffer, actual);
Assert.IsTrue(_serverData.Take(_numberOfBytesToRead, _numberOfBytesToWriteToReadBuffer).IsEqualTo(buffer.Take(_numberOfBytesToWriteToReadBuffer)));
Assert.AreEqual(0, buffer[_numberOfBytesToWriteToReadBuffer]);
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)(_serverData.Length), _readBufferSize));
}
public void FlushShouldFlushBuffer()
{
byte[] actualFlushedData = null;
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.IsOpen)
.Returns(true);
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.RequestWrite(_handle, _expectedWrittenByteCount, It.IsAny <byte[]>(), 0, _expectedBufferedByteCount, It.IsAny <AutoResetEvent>(), null))
.Callback <byte[], ulong, byte[], int, int, AutoResetEvent, Action <SftpStatusResponse> >((handle, serverFileOffset, data, offset, length, wait, writeCompleted) => actualFlushedData = data.Take(offset, length));
_target.Flush();
Assert.IsTrue(actualFlushedData.IsEqualTo(_expectedBufferedBytes));
SftpSessionMock.Verify(p => p.RequestWrite(_handle, _expectedWrittenByteCount, It.IsAny <byte[]>(), 0, _expectedBufferedByteCount, It.IsAny <AutoResetEvent>(), null), Times.Once);
}
public void ReadShouldStartReadingAtBeginningOfFile()
{
var buffer = new byte[8];
var data = new byte[] { 5, 4, 3, 2, 1 };
var expected = new byte[] { 0, 5, 4, 3, 2, 1, 0, 0 };
SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
SftpSessionMock.InSequence(MockSequence).Setup(p => p.RequestRead(_handle, 0UL, _readBufferSize)).Returns(data);
var actual = _target.Read(buffer, 1, data.Length);
Assert.AreEqual(data.Length, actual);
Assert.IsTrue(buffer.IsEqualTo(expected));
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(1));
SftpSessionMock.Verify(p => p.RequestRead(_handle, 0UL, _readBufferSize), Times.Once);
}
public void ReadBytesThatWereNotBufferedBeforeSeekShouldReadBytesFromServer()
{
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.IsOpen)
.Returns(true);
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.RequestRead(_handle, 0UL, _readBufferSize))
.Returns(_serverData2);
var bytesRead = _target.Read(_buffer, 0, _buffer.Length);
Assert.AreEqual(_buffer.Length, bytesRead);
Assert.IsTrue(_serverData2.Take(_buffer.Length).IsEqualTo(_buffer));
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(3));
SftpSessionMock.Verify(p => p.RequestRead(_handle, 0UL, _readBufferSize), Times.Exactly(2));
}
public void WriteShouldThrowNotSupportedException()
{
var buffer = new byte[_writeBufferSize];
SftpSessionMock.InSequence(MockSequence).Setup(p => p.IsOpen).Returns(true);
try
{
_target.Write(buffer, 0, buffer.Length);
}
catch (NotSupportedException ex)
{
Assert.IsNull(ex.InnerException);
Assert.AreEqual("Write not supported.", ex.Message);
}
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(1));
}
public void ReadShouldReadStartFromSamePositionAsBeforeSetLength()
{
SftpSessionMock.InSequence(_sequence).Setup(p => p.IsOpen).Returns(true);
SftpSessionMock.InSequence(_sequence)
.Setup(p => p.RequestRead(_handle,
(uint)(_readBytes1.Length + _readBytes2.Length),
_readBufferSize))
.Returns(new byte[] { 0x0f });
var byteRead = _sftpFileStream.ReadByte();
Assert.AreEqual(0x0f, byteRead);
SftpSessionMock.Verify(p => p.RequestRead(_handle,
(uint)(_readBytes1.Length + _readBytes2.Length),
_readBufferSize),
Times.Once);
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(4));
}
public void ReadShouldReturnReadBytesFromServer()
{
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.IsOpen)
.Returns(true);
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.RequestRead(_handle, 0UL, _readBufferSize))
.Returns(new byte[] { 0x05, 0x04 });
var buffer = new byte[1];
var bytesRead = _target.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, bytesRead);
Assert.AreEqual(0x05, buffer[0]);
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(3));
SftpSessionMock.Verify(p => p.RequestRead(_handle, 0UL, _readBufferSize), Times.Exactly(2));
}
public void ReadShouldReadFromServer()
{
var serverBytes2 = GenerateRandom(5);
var readBytes2 = new byte[5];
var expectedReadBytes = new ArrayBuilder <byte>().Add(new byte[2])
.Add(serverBytes2.Take(0, 3))
.Build();
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.IsOpen)
.Returns(true);
SftpSessionMock.InSequence(MockSequence)
.Setup(p => p.RequestRead(_handle, (ulong)_readBytes.Length, _readBufferSize))
.Returns(serverBytes2);
var bytesRead = _target.Read(readBytes2, 2, 3);
Assert.AreEqual(3, bytesRead);
CollectionAssert.AreEqual(expectedReadBytes, readBytes2);
SftpSessionMock.Verify(p => p.RequestRead(_handle, (ulong)_readBytes.Length, _readBufferSize), Times.Once);
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(3));
}
public void WriteShouldStartFromEndOfStream()
{
var bytesToWrite = GenerateRandom(_writeBufferSize);
byte[] bytesWritten = null;
SftpSessionMock.InSequence(_sequence).Setup(p => p.IsOpen).Returns(true);
SftpSessionMock.InSequence(_sequence)
.Setup(p => p.RequestWrite(_handle, (uint)_length, It.IsAny <byte[]>(), 0, bytesToWrite.Length, It.IsAny <AutoResetEvent>(), null))
.Callback <byte[], ulong, byte[], int, int, AutoResetEvent, Action <SftpStatusResponse> >((handle, serverOffset, data, offset, length, wait, writeCompleted) =>
{
bytesWritten = data.Take(offset, length);
wait.Set();
});
_sftpFileStream.Write(bytesToWrite, 0, bytesToWrite.Length);
Assert.IsNotNull(bytesWritten);
CollectionAssert.AreEqual(bytesToWrite, bytesWritten);
SftpSessionMock.Verify(p => p.RequestWrite(_handle, (uint)_length, It.IsAny <byte[]>(), 0, bytesToWrite.Length, It.IsAny <AutoResetEvent>(), null), Times.Once);
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(4));
}
public void IsOpenOnSftpSessionShouldBeInvokedOnce()
{
SftpSessionMock.Verify(p => p.IsOpen, Times.Once);
}
public void RequestCloseOnSftpSessionShouldNeverBeInvoked()
{
SftpSessionMock.Verify(p => p.RequestClose(_handle), Times.Never);
}
public void RequestWriteOnSftpSessionShouldBeInvokedTwice()
{
SftpSessionMock.Verify(p => p.RequestWrite(_handle, 0, _data, _offset, (int)_writeBufferSize, It.IsAny <AutoResetEvent>(), null), Times.Once);
SftpSessionMock.Verify(p => p.RequestWrite(_handle, _writeBufferSize, _data, _offset + (int)_writeBufferSize, (int)_writeBufferSize, It.IsAny <AutoResetEvent>(), null), Times.Once);
}
public void BeginCloseOnSftpSessionShouldHaveBeenInvokedOnce()
{
SftpSessionMock.Verify(p => p.BeginClose(_handle, null, null), Times.Once);
}
public void BeginCloseOnSftpSessionShouldNeverHaveBeenInvoked()
{
SftpSessionMock.Verify(p => p.BeginClose(_handle, null, null), Times.Never);
}
public void RequestFStatOnSftpSessionShouldBeInvokedOnce()
{
SftpSessionMock.Verify(p => p.RequestFStat(_handle, false), Times.Once);
}
public void RequestOpenOnSftpSessionShouldBeInvokedOnce()
{
SftpSessionMock.Verify(p => p.RequestOpen(_path, Flags.Write | Flags.Append | Flags.CreateNewOrOpen, false), Times.Once);
}
public void IsOpenOnSftpSessionShouldNeverBeInvoked()
{
SftpSessionMock.Verify(p => p.IsOpen, Times.Never);
}
public void HandleShouldHaveBeenClosed()
{
SftpSessionMock.Verify(p => p.BeginClose(_handle, null, null), Times.Once);
SftpSessionMock.Verify(p => p.EndClose(_closeAsyncResult), Times.Once);
}
public void RequestOpenOnSftpSessionShouldBeInvokedOnceWithTruncateAndOnceWithCreateNew()
{
SftpSessionMock.Verify(p => p.RequestOpen(_path, Flags.Write | Flags.Truncate, true), Times.Once);
SftpSessionMock.Verify(p => p.RequestOpen(_path, Flags.Write | Flags.CreateNew, false), Times.Once);
}
public void ExceptionInReadAheadShouldPreventFurtherReadAheads()
{
SftpSessionMock.Verify(p => p.BeginRead(_handle, 2 * ChunkLength, ChunkLength, It.IsNotNull <AsyncCallback>(), It.IsAny <BufferedRead>()), Times.Never);
}
public void RequestCloseOnSftpSessionShouldBeInvokedOnce()
{
SftpSessionMock.Verify(p => p.RequestClose(_handle), Times.Once);
}
public void RequestOpenOnSftpSessionShouldBeInvokedOnce()
{
SftpSessionMock.Verify(p => p.RequestOpen(_path, Flags.Read | Flags.Write | Flags.Truncate, false), Times.Once);
}
public void RequestFSetStatOnSftpSessionShouldBeInvokedOnce()
{
SftpSessionMock.Verify(p => p.RequestFSetStat(_handle, _fileAttributes), Times.Once);
}
public void EndCloseOnSftpSessionShouldHaveBeenInvokedOnce()
{
SftpSessionMock.Verify(p => p.EndClose(_closeAsyncResult), Times.Once);
}
public void IsOpenOnSftpSessionShouldHaveBeenInvokedTwice()
{
SftpSessionMock.Verify(p => p.IsOpen, Times.Exactly(2));
}
