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 Expression Ref <T>(T value)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
return ArgExpr.Ref <T>(value);
}));
}
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 Matches <T>(Expression <Predicate <T> > match)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
return ArgExpr.Matches <T>(match);
}));
}
public Expression IsNull <T>()
{
return(ProfilerInterceptor.GuardInternal(() =>
{
return ArgExpr.IsNull <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 ShouldArrangeNonPublicMethodWithMatchersViaDynaMock()
{
var mock = Mock.Create <TestBed>();
dynamic wrapper = Mock.NonPublic.Wrap(mock);
var acc = new TestBed.Accessor(mock);
Mock.NonPublic.Arrange <int>(wrapper.Get(ArgExpr.Matches <int>(x => x > 40), ArgExpr.IsAny <string>())).Returns(123);
Assert.Equal(0, acc.Get(20, "ss"));
Assert.Equal(123, acc.Get(50, "dd"));
}
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 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 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 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 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 Read_CallsServicesAndInternalOverload()
{
var settingName = new SettingName("prefix", "namespace", "type", "member", "instance");
var settingNameFactory = Mock.Create <ISettingNameFactory>();
var settingConverter = Mock.Create <ISettingConverter>();
settingNameFactory
.Arrange(x => x.CreateProviderSettingName(
Arg.Matches <SettingName>(sn => sn == settingName),
Arg.IsAny <SettingProviderNaming>())
)
.Returns(settingName)
.OccursOnce();
settingConverter
.Arrange(x => x.Deserialize(
Arg.Matches <object>(value => value == (object)"TestValue"),
Arg.Matches <Type>(type => type == typeof(string))
))
.Returns("TestValue")
.OccursOnce();
var settingProvider = Mock.Create <SettingProvider>(Behavior.CallOriginal, settingNameFactory, settingConverter);
Mock
.NonPublic
.Arrange <ISetting>(
settingProvider,
nameof(SettingProvider.Read),
ArgExpr.Matches <SettingName>(sn => sn == settingName)
)
.Returns(new Setting(settingName.ToString(), "TestValue"))
.MustBeCalled();
var setting = settingProvider.Read(new SelectQuery(settingName, typeof(string)));
settingNameFactory.Assert();
settingProvider.Assert();
settingConverter.Assert();
Assert.IsNotNull(setting);
Assert.AreEqual(settingName, setting.Name);
Assert.AreEqual("TestValue", setting.Value);
}
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 ShouldMockOverloadUsingConcreteValues()
{
var foo = Mock.Create <Foo>(Behavior.CallOriginal);
bool called = false, called2 = false;
Mock.NonPublic
.Arrange(foo, "ExecuteProtected", 10, ArgExpr.IsNull <FooDerived>())
.DoInstead(() => called = true);
Mock.NonPublic
.Arrange(foo, "ExecuteProtected", ArgExpr.IsNull <FooDerived>(), 10)
.DoInstead(() => called2 = true);
foo.Execute(10, null);
foo.Execute(null, 10);
Assert.True(called);
Assert.True(called2);
}
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 Write_CallsServicesAndInternalOverload()
{
var settingName = new SettingName("prefix", "namespace", "type", "member", "instance");
var settingNameFactory = Mock.Create <ISettingNameFactory>();
var settingConverter = Mock.Create <ISettingConverter>();
settingNameFactory
.Arrange(x => x.CreateProviderSettingName(
Arg.Matches <SettingName>(sn => sn == settingName),
Arg.IsAny <SettingProviderNaming>())
)
.Returns(settingName)
.OccursOnce();
settingConverter
.Arrange(x => x.Serialize(
Arg.Matches <object>(value => value == (object)"TestValue"))
)
.Returns("TestValue")
.OccursOnce();
var settingProvider = Mock.Create <SettingProvider>(Behavior.CallOriginal, settingNameFactory, settingConverter);
Mock
.NonPublic
.Arrange(
settingProvider,
nameof(SettingProvider.Write),
ArgExpr.Matches <ISetting>(s => s.Name == settingName)
)
.MustBeCalled();
settingProvider.Write(new UpdateQuery(settingName, "TestValue"));
settingNameFactory.Assert();
settingProvider.Assert();
settingConverter.Assert();
}
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 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);
}
public override MSet <string> FreeVars()
{
return(FunExpr.FreeVars().Union(ArgExpr.FreeVars()));
}
public void ShouldNotArrangeNonPublicUsingConstantArgumentWhereByRefIsExpected()
{
var foo = Mock.Create <RefTest>(Behavior.CallOriginal);
Assert.Throws <MissingMemberException>(() => Mock.NonPublic.Arrange(foo, "Test", ArgExpr.IsAny <string>(), "asd"));
}
internal static MethodInfo GetMethodByName(Type type, Type returnType, string memberName, ref object[] args)
{
if (type.IsProxy())
{
type = type.BaseType;
}
var candidateMethods = type.GetAllMethods()
.Where(m => m.Name == memberName)
.Concat(type.GetAllProperties()
.Where(p => p.Name == memberName)
.SelectMany(p => new[] { p.GetGetMethod(true), p.GetSetMethod(true) })
.Where(m => m != null))
.Select(m =>
{
if (m.IsGenericMethodDefinition &&
returnType != typeof(void) &&
m.GetGenericArguments().Length == 1 &&
m.ReturnType.ContainsGenericParameters)
{
var generics = new Dictionary <Type, Type>();
if (MockingUtil.GetGenericsTypesFromActualType(m.ReturnType, returnType, generics))
{
return(m.MakeGenericMethod(generics.Values.Single()));
}
}
return(m);
})
.ToArray();
MethodInfo mockedMethod = null;
if (candidateMethods.Length == 1)
{
var singleCandidate = candidateMethods[0];
var returnTypeMatches = ReturnTypeMatches(returnType, singleCandidate);
var argsIgnored = args == null || args.Length == 0;
if (returnTypeMatches && argsIgnored)
{
mockedMethod = singleCandidate;
args = mockedMethod.GetParameters()
.Select(p =>
{
var byref = p.ParameterType.IsByRef;
var paramType = byref ? p.ParameterType.GetElementType() : p.ParameterType;
if (paramType.IsPointer)
{
paramType = typeof(IntPtr);
}
var isAny = (Expression)typeof(ArgExpr).GetMethod("IsAny").MakeGenericMethod(paramType).Invoke(null, null);
if (byref)
{
isAny = ArgExpr.Ref(isAny);
}
return(isAny);
})
.ToArray();
}
}
if (mockedMethod == null)
{
mockedMethod = FindMethodBySignature(candidateMethods, returnType, args);
if (mockedMethod == null && returnType == typeof(void))
{
mockedMethod = FindMethodBySignature(candidateMethods, null, args);
}
}
if (mockedMethod == null)
{
var mockedProperty = type.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)
.FirstOrDefault(property => property.Name == memberName);
if (mockedProperty != null)
{
var getter = mockedProperty.GetGetMethod(true);
if (getter != null && getter.ArgumentsMatchSignature(args))
{
mockedMethod = getter;
}
if (mockedMethod == null)
{
var setter = mockedProperty.GetSetMethod(true);
if (setter != null && setter.ArgumentsMatchSignature(args))
{
mockedMethod = setter;
}
}
if (mockedMethod == null)
{
throw new MissingMemberException(BuildMissingMethodMessage(type, mockedProperty, memberName));
}
}
}
if (mockedMethod == null)
{
throw new MissingMemberException(BuildMissingMethodMessage(type, null, memberName));
}
if (mockedMethod.ContainsGenericParameters)
{
mockedMethod = MockingUtil.GetRealMethodInfoFromGeneric(mockedMethod, args);
}
if (mockedMethod.DeclaringType != mockedMethod.ReflectedType)
{
mockedMethod = GetMethodByName(mockedMethod.DeclaringType, returnType, memberName, ref args);
}
return(mockedMethod);
}
public void ShouldFailToChainReturnsCallToActionExpectationFromNonPublicInterface()
{
var mock = Mock.Create <IGuidResolver>();
Assert.Throws <MockException>(() => Mock.NonPublic.Arrange(mock, "GetGuid", ArgExpr.IsNull <string>()).Returns((Guid?)new Guid()));
}
