public void Encrypted_RunSync_IOException()
{
// ARRANGE
byte[] fileMock = new byte[1888];
new Random().NextBytes(fileMock);
Stream s = new MemoryStream(fileMock);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
FileUploadCallbackMock callback = new FileUploadCallbackMock();
ApiCreateFileUpload acfu = FactoryFile.ApiCreateFileUpload;
acfu.Classification = null;
EncFileUpload f = new EncFileUpload(c, "id1", FactoryFile.UploadFileRequest, s, FactoryUser.UserPublicKey, fileMock.Length);
f.AddFileUploadCallback(callback);
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(acfu);
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock());
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken);
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(FactoryServerSettings.ApiGeneralSettings).Occurs(1);
Mock.Arrange(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString)).Returns(FactoryFile.PlainFileKey);
FileEncryptionCipher cipher = Mock.Create <FileEncryptionCipher>();
Mock.Arrange(() => Crypto.Sdk.Crypto.CreateFileEncryptionCipher(Arg.IsAny <PlainFileKey>())).Returns(cipher);
Mock.Arrange(() => cipher.ProcessBytes(Arg.IsAny <PlainDataContainer>())).Returns(new EncryptedDataContainer(fileMock, fileMock));
Mock.Arrange(() => cipher.DoFinal()).Returns(new EncryptedDataContainer(fileMock, fileMock));
Mock.NonPublic.Arrange <ApiUploadChunkResult>(f, "UploadChunkWebClient", ArgExpr.IsAny <Uri>(), ArgExpr.IsAny <byte[]>(),
ArgExpr.IsAny <long>(), ArgExpr.IsAny <int>()).Throws(new IOException());
// ACT - ASSERT
Assert.Throws <DracoonFileIOException>(() => f.RunSync());
s.Close();
}
public void ShouldArrangeNonPublicMethodReturningGenericValue()
{
var mock = Mock.Create <GenericTest>(Behavior.CallOriginal);
Mock.NonPublic.Arrange <int>(mock, "Do", ArgExpr.IsAny <int>()).Returns(123);
Assert.Equal(123, mock.TestDo());
}
public Expression IsAny <T>()
{
return(ProfilerInterceptor.GuardInternal(() =>
{
return ArgExpr.IsAny <T>();
}));
}
public Expression IsAny(Type type, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
return ArgExpr.IsAny(type, args);
}));
}
public void Encrypted_RunSync_ProcessBytesIOError()
{
// ARRANGE
Node node = FactoryNode.Node;
node.Size = 1024;
byte[] expected = new byte[node.Size.Value];
new Random().NextBytes(expected);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock();
Stream s = new MemoryStream();
FileDownloadCallbackMock callback = new FileDownloadCallbackMock();
EncFileDownload f = new EncFileDownload(c, "id1", node, s, FactoryUser.UserPrivateKey);
f.AddFileDownloadCallback(callback);
Mock.Arrange(() => c.Builder.PostFileDownload(Arg.AnyLong)).Returns(FactoryRestSharp.PostFileDownloadMock(2354));
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiDownloadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostDownloadToken, 0))
.Returns(FactoryNode.ApiDownloadToken);
Mock.Arrange(() => c.NodesImpl.GetEncryptedFileKey(Arg.AnyLong)).Returns(FactoryFile.EncryptedFileKey);
FileDecryptionCipher cipher = Mock.Create <FileDecryptionCipher>();
Mock.Arrange(() => Crypto.Sdk.Crypto.DecryptFileKey(Arg.IsAny <EncryptedFileKey>(), Arg.IsAny <UserPrivateKey>(), Arg.AnyString))
.Returns(FactoryFile.PlainFileKey);
Mock.Arrange(() => Crypto.Sdk.Crypto.CreateFileDecryptionCipher(Arg.IsAny <PlainFileKey>())).Returns(cipher);
Mock.NonPublic.Arrange <byte[]>(f, "DownloadChunk", ArgExpr.IsAny <Uri>(), ArgExpr.IsAny <long>(), ArgExpr.IsAny <long>()).Returns(expected);
Mock.Arrange(() => cipher.ProcessBytes(Arg.IsAny <EncryptedDataContainer>())).Throws(new IOException("Error"));
Mock.Arrange(() => cipher.DoFinal(Arg.IsAny <EncryptedDataContainer>())).Returns(new PlainDataContainer(new byte[0]));
// ACT
Assert.Throws <DracoonFileIOException>(() => f.RunSync());
s.Close();
}
public void ShouldArrangeNonPublicUsingByRefArgumentWithMatcher()
{
var foo = Mock.Create <RefTest>(Behavior.CallOriginal);
Mock.NonPublic.Arrange(foo, "Test", ArgExpr.IsAny <string>(), ArgExpr.Ref(ArgExpr.IsAny <string>())).MustBeCalled();
string asd = "asd";
foo.ExecuteTest(ref asd);
Mock.Assert(foo);
}
public void ShouldAssertNonPublicMethodViaDynaMock()
{
var mock = Mock.Create <TestBed>();
var wrapper = Mock.NonPublic.Wrap(mock);
Assert.Throws <AssertionException>(() => Mock.NonPublic.Assert(wrapper.Value = 123, Occurs.Once()));
Assert.Throws <AssertionException>(() => Mock.NonPublic.Assert(wrapper.Value = ArgExpr.IsAny <int>(), Occurs.Once()));
new TestBed.Accessor(mock).Value = 123;
Mock.NonPublic.Assert(wrapper.Value = 123, Occurs.Once());
Mock.NonPublic.Assert(wrapper.Value = ArgExpr.IsAny <int>(), Occurs.Once());
}
public void ShouldArrangeNonPublicUsingByRefArgumentAsOutputParameter()
{
var foo = Mock.Create <RefTest>(Behavior.CallOriginal);
Mock.NonPublic.Arrange(foo, "Test", ArgExpr.IsAny <string>(), ArgExpr.Out("asd"));
string input = "";
foo.ExecuteTest(ref input);
Assert.Equal("asd", input);
}
public void ShouldArrangeNonPublicSetterWithMatchersViaDynaMock()
{
var mock = Mock.Create <TestBed>();
dynamic wrapper = Mock.NonPublic.Wrap(mock);
Mock.NonPublic.Arrange(wrapper.Value = ArgExpr.IsAny <int>()).MustBeCalled();
Assert.Throws <AssertionException>(() => Mock.Assert(mock));
new TestBed.Accessor(mock).Value = 77;
Mock.Assert(mock);
}
public void ShouldMockOverloadUsingMatchers()
{
var foo = Mock.Create <Foo>(Behavior.CallOriginal);
bool called = false;
Mock.NonPublic
.Arrange(foo, "ExecuteProtected", ArgExpr.IsAny <int>(), ArgExpr.IsNull <Foo>())
.DoInstead(() => called = true);
foo.Execute(10, null);
Assert.True(called);
}
public void Encrypted_RunSync_Success()
{
// ARRANGE
Node node = FactoryNode.Node;
node.Size = 1024;
byte[] expected = new byte[node.Size.Value];
new Random().NextBytes(expected);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock();
Stream s = new MemoryStream();
FileDownloadCallbackMock callback = new FileDownloadCallbackMock();
EncFileDownload f = new EncFileDownload(c, "id1", node, s, FactoryUser.UserPrivateKey);
f.AddFileDownloadCallback(callback);
Mock.Arrange(() => c.Builder.PostFileDownload(Arg.AnyLong)).Returns(FactoryRestSharp.PostFileDownloadMock(2354)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiDownloadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostDownloadToken, 0))
.Returns(FactoryNode.ApiDownloadToken).Occurs(1);
Mock.Arrange(() => c.NodesImpl.GetEncryptedFileKey(Arg.AnyLong)).Returns(FactoryFile.EncryptedFileKey).Occurs(1);
FileDecryptionCipher cipher = Mock.Create <FileDecryptionCipher>();
Mock.Arrange(() => Crypto.Sdk.Crypto.DecryptFileKey(Arg.IsAny <EncryptedFileKey>(), Arg.IsAny <UserPrivateKey>(), Arg.AnyString))
.Returns(FactoryFile.PlainFileKey).Occurs(1);
Mock.Arrange(() => Crypto.Sdk.Crypto.CreateFileDecryptionCipher(Arg.IsAny <PlainFileKey>())).Returns(cipher).Occurs(1);
Mock.NonPublic.Arrange <byte[]>(f, "DownloadChunk", ArgExpr.IsAny <Uri>(), ArgExpr.IsAny <long>(), ArgExpr.IsAny <long>()).Returns(expected);
Mock.Arrange(() => cipher.ProcessBytes(Arg.IsAny <EncryptedDataContainer>())).Returns(new PlainDataContainer(expected)).OccursAtLeast(1);
Mock.Arrange(() => cipher.DoFinal(Arg.IsAny <EncryptedDataContainer>())).Returns(new PlainDataContainer(new byte[0])).Occurs(1);
Mock.Arrange(() => callback.OnStarted(Arg.AnyString)).Occurs(1);
Mock.Arrange(() => callback.OnRunning(Arg.AnyString, Arg.AnyLong, Arg.AnyLong)).OccursAtLeast(1);
Mock.Arrange(() => callback.OnFinished(Arg.AnyString)).Occurs(1);
// ACT
f.RunSync();
s.Position = 0;
byte[] actual = new byte[expected.Length];
s.Read(actual, 0, expected.Length);
s.Close();
// ASSERT
Assert.Equal(expected, actual);
Mock.Assert(() => Crypto.Sdk.Crypto.DecryptFileKey(Arg.IsAny <EncryptedFileKey>(), Arg.IsAny <UserPrivateKey>(), Arg.AnyString));
Mock.Assert(() => Crypto.Sdk.Crypto.CreateFileDecryptionCipher(Arg.IsAny <PlainFileKey>()));
Mock.Assert(callback);
Mock.Assert(cipher);
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
Mock.Assert(c.NodesImpl);
}
public void Echo_OnExecute_ShouldReturnTheExpectationsForPrivateEcho()
{
var expected = 1;
Foo foo = new Foo();
// ARRANGE - When the non-public function PrivateEcho() is called from the foo instance, with any integer argument,
// it should return expected integer.
Mock.NonPublic.Arrange <int>(foo, "PrivateEcho", ArgExpr.IsAny <int>()).Returns(expected);
// ACT
int actual = foo.Echo(5);
// ASSERT
Assert.AreEqual(expected, actual);
}
public void CallsSerializeCoreWithFallbackTypeWhenTypeNotSupported()
{
var settingConverter = Mock.Create <SettingConverter>(Behavior.CallOriginal, (IEnumerable <Type>) new[] { typeof(string) }, typeof(string));
Mock
.NonPublic
.Arrange <object>(
settingConverter,
"SerializeCore",
ArgExpr.IsAny <object>(),
ArgExpr.Matches <Type>(t => t == typeof(string)))
.OccursOnce();
settingConverter.Serialize(123);
settingConverter.Assert();
}
public void DoesNotCallSerializeCoreWhenSameTypes()
{
var settingConverter = Mock.Create <SettingConverter>(Behavior.CallOriginal, (IEnumerable <Type>) new[] { typeof(string) }, typeof(string));
Mock
.NonPublic
.Arrange <object>(
settingConverter,
"SerializeCore",
ArgExpr.IsAny <object>(),
ArgExpr.IsAny <Type>())
.OccursNever();
settingConverter.Serialize("foo");
settingConverter.Assert();
}
public void CallsDeserializeCoreWhenDifferentTypes()
{
var settingConverter = Mock.Create <SettingConverter>(Behavior.CallOriginal, (IEnumerable <Type>) new[] { typeof(string) }, typeof(string));
Mock
.NonPublic
.Arrange <object>(
settingConverter,
"DeserializeCore",
ArgExpr.IsAny <object>(),
ArgExpr.IsAny <Type>())
.OccursOnce();
settingConverter.Deserialize("foo", typeof(int));
settingConverter.Assert();
}
public void ShouldArrangeNonPublicUsingByRefArgumentWithConstant()
{
int call = 1;
int callA = 0, callB = 0;
var foo = Mock.Create <RefTest>(Behavior.CallOriginal);
Mock.NonPublic.Arrange(foo, "Test", ArgExpr.IsAny <string>(), ArgExpr.Ref(ArgExpr.IsAny <string>())).DoInstead(() => callB = call++);
Mock.NonPublic.Arrange(foo, "Test", ArgExpr.IsAny <string>(), ArgExpr.Ref("asd")).DoInstead(() => callA = call++);
string input = "asd";
foo.ExecuteTest(ref input);
input = "foo";
foo.ExecuteTest(ref input);
Assert.Equal(1, callA);
Assert.Equal(2, callB);
}
public void ShouldInvokeNonPublicMemberDynamic()
{
// Arrange
Mock.Arrange(() => new Foo()).DoNothing();
Foo foo = new Foo();
dynamic fooAcc = Mock.NonPublic.Wrap(foo);
Mock.NonPublic.Arrange <int>(fooAcc.PrivateEcho(ArgExpr.IsAny <int>())).Returns(10);
Mock.NonPublic.Arrange <string>(fooAcc.Value).Returns("foo");
Mock.NonPublic.Arrange(fooAcc.Value = "abc").OccursOnce();
// Act
var actual = foo.Echo(5);
var value = foo.GetType().GetField("Value");
// Assert
Assert.AreEqual(10, actual);
Assert.AreEqual("foo", value);
Mock.Assert(foo);
}
public void ShouldMockInternaldotNETClass()
{
var isCalled = false;
// ARRANGE
// We are about to mock System.Net.HttpRequestCreator(), which is a non-public class.
string typeName = "System.Net.HttpRequestCreator";
// Creating a mocked instance of the System.Net.HttpRequestCreator internal class.
var httpRequestCreator = Mock.Create(typeName);
// Arranging: When the non-public Create() method is called from the httpRequestCreator instance, with any Uri
// argument, it should assign true to isCalled instead of executing its original logic.
Mock.NonPublic.Arrange(httpRequestCreator, "Create", ArgExpr.IsAny <Uri>()).DoInstead(() => isCalled = true);
// ACT
System.Net.IWebRequestCreate iWebRequestCreate = (System.Net.IWebRequestCreate)httpRequestCreator;
iWebRequestCreate.Create(new Uri("http://www.telerik.com"));
// ASSERT
Assert.IsTrue(isCalled);
}
public void ShouldArrangeNonPublicMethodWithMatchersViaDynaMock()
{
var mock = Mock.Create <TestBed>();
dynamic wrapper = Mock.NonPublic.Wrap(mock);
Mock.NonPublic.Arrange <int>(wrapper.Get(ArgExpr.Matches <int>(x => x > 40), ArgExpr.IsAny <string>())).Returns(123);
var acc = new TestBed.Accessor(mock);
Assert.Equal(0, acc.Get(20, "ss"));
Assert.Equal(123, acc.Get(50, "dd"));
}
public void ShouldNotArrangeNonPublicUsingConstantArgumentWhereByRefIsExpected()
{
var foo = Mock.Create <RefTest>(Behavior.CallOriginal);
Assert.Throws <MissingMemberException>(() => Mock.NonPublic.Arrange(foo, "Test", ArgExpr.IsAny <string>(), "asd"));
}
public void Encrypted_RunSync_KnownFileSize_Success()
{
// ARRANGE
byte[] fileMock = new byte[1888];
new Random().NextBytes(fileMock);
Stream s = new MemoryStream(fileMock);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
FileUploadCallbackMock callback = new FileUploadCallbackMock();
ApiCreateFileUpload acfu = FactoryFile.ApiCreateFileUpload;
acfu.Classification = null;
EncFileUpload f = new EncFileUpload(c, "id1", FactoryFile.UploadFileRequest, s, FactoryUser.UserPublicKey, fileMock.Length);
f.AddFileUploadCallback(callback);
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(acfu).Occurs(1);
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock())
.Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken).Occurs(1);
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(FactoryServerSettings.ApiGeneralSettings).Occurs(1);
Mock.Arrange(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString)).Returns(FactoryFile.PlainFileKey).Occurs(1);
FileEncryptionCipher cipher = Mock.Create <FileEncryptionCipher>();
Mock.Arrange(() => Crypto.Sdk.Crypto.CreateFileEncryptionCipher(Arg.IsAny <PlainFileKey>())).Returns(cipher).Occurs(1);
Mock.Arrange(() => cipher.ProcessBytes(Arg.IsAny <PlainDataContainer>())).Returns(new EncryptedDataContainer(fileMock, fileMock))
.OccursAtLeast(1);
Mock.Arrange(() => cipher.DoFinal()).Returns(new EncryptedDataContainer(fileMock, fileMock)).OccursAtLeast(1);
Mock.NonPublic.Arrange <ApiUploadChunkResult>(f, "UploadChunkWebClient", ArgExpr.IsAny <Uri>(), ArgExpr.IsAny <byte[]>(),
ArgExpr.IsAny <long>(), ArgExpr.IsAny <int>()).Returns(FactoryFile.ApiUploadChunkResult).OccursAtLeast(1);
Mock.Arrange(() => FileHash.CompareFileHashes(Arg.AnyString, Arg.IsAny <byte[]>(), Arg.AnyInt)).Returns(true).OccursAtLeast(1);
Mock.Arrange(() => Crypto.Sdk.Crypto.EncryptFileKey(Arg.IsAny <PlainFileKey>(), Arg.IsAny <UserPublicKey>()))
.Returns(FactoryFile.EncryptedFileKey).Occurs(1);
Mock.Arrange(() => FileMapper.ToApiCompleteFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(FactoryFile.ApiCompleteFileUpload)
.Occurs(1);
Mock.Arrange(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>())).Returns(FactoryFile.ApiFileKey);
Mock.Arrange(() => c.Builder.PutCompleteFileUpload(Arg.AnyString, Arg.IsAny <ApiCompleteFileUpload>()))
.Returns(FactoryRestSharp.PutCompleteFileUploadMock("path")).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiNode>(Arg.IsAny <IRestRequest>(), RequestType.PutCompleteUpload, 0))
.Returns(FactoryNode.ApiNode).Occurs(1);
Mock.Arrange(() => NodeMapper.FromApiNode(Arg.IsAny <ApiNode>())).Returns(FactoryNode.Node).Occurs(1);
Mock.Arrange(() => callback.OnStarted(Arg.AnyString)).Occurs(1);
Mock.Arrange(() => callback.OnRunning(Arg.AnyString, Arg.AnyLong, Arg.AnyLong)).OccursAtLeast(1);
Mock.Arrange(() => callback.OnFinished(Arg.AnyString, Arg.IsAny <Node>())).Occurs(1);
// ACT
Node actual = f.RunSync();
s.Close();
// ASSERT
Assert.Equal(FactoryNode.Node, actual, new NodeComparer());
Mock.Assert(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>()));
Mock.Assert(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString));
Mock.Assert(() => Crypto.Sdk.Crypto.CreateFileEncryptionCipher(Arg.IsAny <PlainFileKey>()));
Mock.Assert(() => FileHash.CompareFileHashes(Arg.AnyString, Arg.IsAny <byte[]>(), Arg.AnyInt));
Mock.Assert(() => Crypto.Sdk.Crypto.EncryptFileKey(Arg.IsAny <PlainFileKey>(), Arg.IsAny <UserPublicKey>()));
Mock.Assert(() => FileMapper.ToApiCompleteFileUpload(Arg.IsAny <FileUploadRequest>()));
Mock.Assert(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>()));
Mock.Assert(() => NodeMapper.FromApiNode(Arg.IsAny <ApiNode>()));
Mock.Assert(callback);
Mock.Assert(cipher);
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
Mock.Assert(c.NodesImpl);
}
