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 Encrypted_RunSync_CreateFileKeyError()
{
// 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(() => 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(() => 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(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString)).Throws(new CryptoException("Error"));
// ACT - ASSERT
Assert.Throws <DracoonCryptoException>(() => f.RunSync());
s.Close();
}
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 EncFileUpload(IInternalDracoonClient client, string actionId, FileUploadRequest request, Stream input, UserPublicKey publicKey,
long fileSize) : base(client, actionId, request, input, fileSize)
{
_userPublicKey = publicKey;
LogTag = nameof(EncFileUpload);
}
public EncFileDownload(IInternalDracoonClient client, string actionId, Node nodeToDownload, Stream output, UserPrivateKey privateKey) : base(
client, actionId, nodeToDownload, output)
{
_userPrivateKey = privateKey;
Logtag = nameof(EncFileDownload);
}
public void CreateUploadShare_SmsRecipientsNoAccessPw_Fail()
{
// ARRANGE
CreateUploadShareRequest req = FactoryShare.CreateUploadShareRequest;
req.AccessPassword = null;
req.SmsRecipients = new List <string>();
req.EmailRecipients = null;
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonSharesImpl s = new DracoonSharesImpl(c);
Mock.Arrange(() => Arg.IsAny <CreateUploadShareRequest>().MustNotNull(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.AnyLong.MustPositive(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool)).DoNothing().OccursAtLeast(1);
Mock.Arrange(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString)).DoNothing().Occurs(2);
Mock.Arrange(() => Arg.IsAny <long?>().NullableMustPositive(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.IsAny <IEnumerable <string> >().EnumerableMustNotNullOrEmpty(Arg.AnyString)).DoNothing();
// ACT - ASSERT
Assert.Throws <ArgumentException>(() => s.CreateUploadShare(req));
Mock.Assert(() => Arg.IsAny <CreateUploadShareRequest>().MustNotNull(Arg.AnyString));
Mock.Assert(() => Arg.AnyLong.MustPositive(Arg.AnyString));
Mock.Assert(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool));
Mock.Assert(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString));
Mock.Assert(() => Arg.IsAny <long?>().NullableMustPositive(Arg.AnyString));
Mock.Assert(() => Arg.IsAny <IEnumerable <string> >().EnumerableMustNotNullOrEmpty(Arg.AnyString));
Mock.Assert(c.Executor);
}
public void RunAsync_IOException()
{
// ARRANGE
byte[] expected = new byte[FactoryNode.Node.Size.Value];
new Random().NextBytes(expected);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock();
Stream s = new MemoryStream();
FileDownloadCallbackMock callback = new FileDownloadCallbackMock();
FileDownload f = new FileDownload(c, "id1", FactoryNode.Node, s);
f.AddFileDownloadCallback(callback);
Mock.Arrange(() => c.Builder.PostFileDownload(Arg.AnyLong)).Returns(FactoryRestSharp.PostFileDownloadMock(123)).OnAllThreads();
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiDownloadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostDownloadToken, 0))
.Returns(FactoryNode.ApiDownloadToken).OnAllThreads();
DracoonWebClientExtension wc = Mock.Create <DracoonWebClientExtension>();
Mock.Arrange(() => Mock.Create <DownloadProgressChangedEventArgs>().BytesReceived).IgnoreInstance().Returns(expected.Length);
Mock.Arrange(() => c.Executor.ExecuteWebClientDownload(Arg.IsAny <WebClient>(), Arg.IsAny <Uri>(),
RequestType.GetDownloadChunk, Arg.IsAny <Thread>(), Arg.AnyInt))
.Raises(() => wc.DownloadProgressChanged += null, null, Mock.Create <DownloadProgressChangedEventArgs>()).Returns(expected).OnAllThreads();
Mock.Arrange(() => s.Write(Arg.IsAny <byte[]>(), Arg.AnyInt, Arg.AnyInt)).Throws(new IOException()).OnAllThreads();
Mock.Arrange(() => c.Builder.ProvideChunkDownloadWebClient(Arg.AnyLong, Arg.AnyLong)).Returns(wc).OnAllThreads();
Mock.Arrange(() => callback.OnFailed(Arg.AnyString, Arg.IsAny <DracoonException>())).Occurs(1);
// ACT
f.RunAsync();
while (f.RunningThread.IsAlive)
{
}
s.Close();
// ASSERT
Mock.Assert(callback);
}
public void DoSyncApiCall_Success()
{
// ARRANGE
string version = "4.13.0";
DateTime buildTime = new DateTime(2019, 1, 1, 0, 0, 0);
ApiServerVersion expected = new ApiServerVersion {
ServerVersion = version,
RestApiVersion = version,
BuildDate = buildTime
};
RestResponse response = FactoryRestSharp.RestResponse;
response.Content = JsonConvert.SerializeObject(expected);
response.StatusCode = HttpStatusCode.OK;
Mock.NonPublic.Arrange <bool>(response, "IsSuccessful").Returns(true);
IRestRequest request = FactoryRestSharp.GetServerVersionMock();
Mock.Arrange(() => DracoonClient.HttpConfig).Returns(new DracoonHttpConfig {
WebProxy = new WebProxy()
});
Mock.Arrange(() => new RestClient().Execute(request)).IgnoreInstance().Returns(response);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock();
IRequestExecutor exec = new DracoonRequestExecutor(FactoryClients.OAuthMock, c);
// ACT
ApiServerVersion actual = exec.DoSyncApiCall <ApiServerVersion>(request, RequestType.GetServerVersion);
// ASSERT
Assert.Equal(expected.BuildDate, actual.BuildDate);
Assert.Equal(expected.RestApiVersion, actual.RestApiVersion);
Assert.Equal(expected.ServerVersion, actual.ServerVersion);
}
public void GetUploadShares()
{
// ARRANGE
UploadShareList expected = FactoryShare.UploadShareList;
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonSharesImpl s = new DracoonSharesImpl(c);
Mock.Arrange(() => Arg.IsAny <long?>().NullableMustNotNegative(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.IsAny <long?>().NullableMustPositive(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => c.Builder.GetUploadShares(Arg.IsAny <long?>(), Arg.IsAny <long?>(), Arg.IsAny <GetUploadSharesFilter>(), Arg.IsAny <SharesSort>())).Returns(FactoryRestSharp.GetUploadSharesMock()).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadShareList>(Arg.IsAny <IRestRequest>(), RequestType.GetUploadShares, 0))
.Returns(FactoryShare.ApiUploadShareList).Occurs(1);
Mock.Arrange(() => ShareMapper.FromApiUploadShareList(Arg.IsAny <ApiUploadShareList>())).Returns(FactoryShare.UploadShareList).Occurs(1);
// ACT
UploadShareList actual = s.GetUploadShares();
// ASSERT
Assert.NotNull(actual);
Mock.Assert(() => Arg.IsAny <long?>().NullableMustNotNegative(Arg.AnyString));
Mock.Assert(() => Arg.IsAny <long?>().NullableMustPositive(Arg.AnyString));
Mock.Assert(() => ShareMapper.FromApiUploadShareList(Arg.IsAny <ApiUploadShareList>()));
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
public void CreateDownloadShare_NotEncryptedNoAccessPw_Fail()
{
// ARRANGE
Node node = FactoryNode.Node;
node.IsEncrypted = false;
node.Type = NodeType.File;
CreateDownloadShareRequest req = FactoryShare.CreateDownloadShareRequest;
req.AccessPassword = "";
req.EncryptionPassword = null;
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonSharesImpl s = new DracoonSharesImpl(c);
Mock.Arrange(() => Arg.IsAny <CreateDownloadShareRequest>().MustNotNull(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => c.NodesImpl.GetNode(Arg.AnyLong)).Returns(node).Occurs(1);
Mock.Arrange(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, true)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, false)).Throws(new ArgumentException()).Occurs(1);
Mock.Arrange(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString)).DoNothing().Occurs(1);
// ACT - ASSERT
Assert.Throws <ArgumentException>(() => s.CreateDownloadShare(req));
Mock.Assert(() => Arg.IsAny <CreateDownloadShareRequest>().MustNotNull(Arg.AnyString));
Mock.Assert(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, true));
Mock.Assert(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, false));
Mock.Assert(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString));
Mock.Assert(c.NodesImpl);
Mock.Assert(c.Executor);
}
public void CreateDownloadShare_Success()
{
// ARRANGE
Node node = FactoryNode.Node;
node.IsEncrypted = true;
node.Type = NodeType.File;
CreateDownloadShareRequest req = FactoryShare.CreateDownloadShareRequest;
req.EmailRecipients = new List <string> {
"985678"
};
req.EmailBody = "Any body!";
req.EmailSubject = "Any subject!";
req.SmsRecipients = new List <string> {
"28436054"
};
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonSharesImpl s = new DracoonSharesImpl(c);
Mock.Arrange(() => Arg.IsAny <CreateDownloadShareRequest>().MustNotNull(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => c.NodesImpl.GetNode(Arg.AnyLong)).Returns(node).Occurs(1);
Mock.Arrange(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool)).DoNothing().OccursAtLeast(1);
Mock.Arrange(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.IsAny <IEnumerable <string> >().EnumerableMustNotNullOrEmpty(Arg.AnyString)).DoNothing();
Mock.Arrange(() => ShareMapper.ToUnencryptedApiCreateDownloadShareRequest(Arg.IsAny <CreateDownloadShareRequest>()))
.Returns(FactoryShare.ApiCreateDownloadShareRequest).Occurs(1);
Mock.Arrange(() => c.AccountImpl.GetAndCheckUserKeyPair()).Returns(FactoryUser.UserKeyPair).Occurs(1);
Mock.Arrange(() => c.NodesImpl.GetEncryptedFileKey(Arg.AnyLong)).Returns(FactoryFile.EncryptedFileKey).Occurs(1);
Mock.Arrange(() => c.NodesImpl.DecryptFileKey(Arg.IsAny <EncryptedFileKey>(), Arg.IsAny <UserPrivateKey>(), Arg.IsAny <long?>())).Returns(FactoryFile.PlainFileKey).Occurs(1);
Mock.Arrange(() => c.AccountImpl.GenerateNewUserKeyPair(Arg.AnyString)).Returns(FactoryUser.UserKeyPair);
Mock.Arrange(() => c.NodesImpl.EncryptFileKey(Arg.IsAny <PlainFileKey>(), Arg.IsAny <UserPublicKey>(), Arg.IsAny <long?>())).Returns(FactoryFile.EncryptedFileKey).Occurs(1);
Mock.Arrange(() => UserMapper.ToApiUserKeyPair(Arg.IsAny <UserKeyPair>())).Returns(FactoryUser.ApiUserKeyPair).Occurs(1);
Mock.Arrange(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>())).Returns(FactoryFile.ApiFileKey).Occurs(1);
Mock.Arrange(() => c.Builder.PostCreateDownloadShare(Arg.IsAny <ApiCreateDownloadShareRequest>())).Returns(FactoryRestSharp.PostCreateDownloadShareMock()).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiDownloadShare>(Arg.IsAny <IRestRequest>(), RequestType.PostCreateDownloadShare, 0))
.Returns(FactoryShare.ApiDownloadShare).Occurs(1);
Mock.Arrange(() => ShareMapper.FromApiDownloadShare(Arg.IsAny <ApiDownloadShare>())).Returns(FactoryShare.DownloadShare).Occurs(1);
// ACT
DownloadShare actual = s.CreateDownloadShare(req);
// ASSERT
Assert.NotNull(actual);
Mock.Assert(() => Arg.IsAny <CreateDownloadShareRequest>().MustNotNull(Arg.AnyString));
Mock.Assert(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool));
Mock.Assert(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString));
Mock.Assert(() => Arg.IsAny <IEnumerable <string> >().EnumerableMustNotNullOrEmpty(Arg.AnyString));
Mock.Assert(() => ShareMapper.ToUnencryptedApiCreateDownloadShareRequest(Arg.IsAny <CreateDownloadShareRequest>()));
Mock.Assert(() => UserMapper.ToApiUserKeyPair(Arg.IsAny <UserKeyPair>()));
Mock.Assert(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>()));
Mock.Assert(() => ShareMapper.FromApiDownloadShare(Arg.IsAny <ApiDownloadShare>()));
Mock.Assert(c.NodesImpl);
Mock.Assert(c.AccountImpl);
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
public FileUpload(IInternalDracoonClient client, string actionId, FileUploadRequest request, Stream input, long fileSize)
{
Client = client;
ActionId = actionId;
InputStream = input;
FileUploadRequest = request;
OptionalFileSize = fileSize;
LogTag = nameof(FileUpload);
}
public void ServerSettingsProperty()
{
// ARRANGE
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonServerImpl s = new DracoonServerImpl(c);
// ACT
// ASSERT
Assert.NotNull(s.ServerSettings);
}
public void RunAsync_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();
FileUpload f = new FileUpload(c, "id1", FactoryFile.UploadFileRequest, s, fileMock.Length);
f.AddFileUploadCallback(callback);
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock())
.OnAllThreads();
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken).OnAllThreads();
Mock.Arrange(() => c.Builder.PutCompleteFileUpload(Arg.AnyString, Arg.IsAny <ApiCompleteFileUpload>()))
.Returns(FactoryRestSharp.PutCompleteFileUploadMock("path")).OnAllThreads();
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiNode>(Arg.IsAny <IRestRequest>(), RequestType.PutCompleteUpload, 0))
.Returns(FactoryNode.ApiNode).OnAllThreads();
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).OnAllThreads();
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(FactoryServerSettings.ApiGeneralSettings).OnAllThreads();
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(FactoryFile.ApiCreateFileUpload)
.OnAllThreads();
Mock.Arrange(() => NodeMapper.FromApiNode(Arg.IsAny <ApiNode>())).Returns(FactoryNode.Node).OnAllThreads();
Mock.Arrange(() => FileHash.CompareFileHashes(Arg.AnyString, Arg.IsAny <byte[]>(), Arg.AnyInt)).Returns(true).OnAllThreads();
DracoonWebClientExtension wc = Mock.Create <DracoonWebClientExtension>();
Mock.Arrange(() => Mock.Create <UploadProgressChangedEventArgs>().BytesSent).IgnoreInstance().OnAllThreads();
Mock.Arrange(() => c.Executor.ExecuteWebClientChunkUpload(Arg.IsAny <WebClient>(), Arg.IsAny <Uri>(), Arg.IsAny <byte[]>(),
RequestType.PostUploadChunk, Arg.IsAny <Thread>(), Arg.AnyInt))
.Raises(() => wc.UploadProgressChanged += null, null, Mock.Create <UploadProgressChangedEventArgs>()).Returns(new byte[13])
.OnAllThreads();
Mock.Arrange(() => c.Builder.ProvideChunkUploadWebClient(Arg.AnyInt, Arg.AnyLong, Arg.AnyString, Arg.AnyString)).Returns(wc)
.OnAllThreads();
Mock.Arrange(() => JsonConvert.DeserializeObject <ApiUploadChunkResult>(Arg.AnyString)).Returns(FactoryFile.ApiUploadChunkResult)
.OnAllThreads();
Mock.Arrange(() => s.Read(Arg.IsAny <byte[]>(), Arg.AnyInt, Arg.AnyInt)).Throws(new IOException()).OnAllThreads();
Mock.Arrange(() => callback.OnStarted(Arg.AnyString)).Occurs(1);
Mock.Arrange(() => callback.OnFailed(Arg.AnyString, Arg.IsAny <DracoonException>())).Occurs(1);
// ACT
f.RunAsync();
while (f.RunningThread.IsAlive)
{
}
s.Close();
// ASSERT
Mock.Assert(callback);
}
public void RunSync_UnknownFileSize_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();
FileUpload f = new FileUpload(c, "id1", FactoryFile.UploadFileRequest, s, -1);
f.AddFileUploadCallback(callback);
ApiCreateFileUpload acfu = FactoryFile.ApiCreateFileUpload;
acfu.Classification = null;
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.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(() => 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(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(acfu).Occurs(1);
Mock.Arrange(() => NodeMapper.FromApiNode(Arg.IsAny <ApiNode>())).Returns(FactoryNode.Node).Occurs(1);
Mock.Arrange(() => FileHash.CompareFileHashes(Arg.AnyString, Arg.IsAny <byte[]>(), Arg.AnyInt)).Returns(true).OccursAtLeast(1);
DracoonWebClientExtension wc = Mock.Create <DracoonWebClientExtension>();
Mock.Arrange(() => Mock.Create <UploadProgressChangedEventArgs>().BytesSent).IgnoreInstance();
Mock.Arrange(() => c.Executor.ExecuteWebClientChunkUpload(Arg.IsAny <WebClient>(), Arg.IsAny <Uri>(), Arg.IsAny <byte[]>(),
RequestType.PostUploadChunk, Arg.IsAny <Thread>(), Arg.AnyInt)).DoInstead(() => Thread.Sleep(250))
.Raises(() => wc.UploadProgressChanged += null, null, Mock.Create <UploadProgressChangedEventArgs>()).Returns(new byte[13]);
Mock.Arrange(() => c.Builder.ProvideChunkUploadWebClient(Arg.AnyInt, Arg.AnyLong, Arg.AnyString, Arg.AnyString)).Returns(wc);
Mock.Arrange(() => JsonConvert.DeserializeObject <ApiUploadChunkResult>(Arg.AnyString)).Returns(FactoryFile.ApiUploadChunkResult);
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(callback);
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
public void CheckUserKeyPairPassword_Fail()
{
// ARRANGE
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonAccountImpl a = new DracoonAccountImpl(c);
Mock.Arrange(() => a.GetAndCheckUserKeyPair()).Throws(new DracoonCryptoException()).Occurs(1);
// ACT - ASSERT
Assert.Throws <DracoonCryptoException>(() => a.CheckUserKeyPairPassword());
Mock.Assert(a);
Mock.Assert(c.Executor);
}
public void GenerateNewUserKeyPair_Fail()
{
// ARRANGE
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonAccountImpl a = new DracoonAccountImpl(c);
Mock.Arrange(() => Crypto.Sdk.Crypto.GenerateUserKeyPair(Arg.AnyString)).Throws(new CryptoException()).Occurs(1);
Mock.Arrange(() => CryptoErrorMapper.ParseCause(Arg.IsAny <Exception>())).Returns(DracoonCryptoCode.UNKNOWN_ERROR).Occurs(1);
// ACT - ASSERT
Assert.Throws <DracoonCryptoException>(() => a.GenerateNewUserKeyPair(c.EncryptionPassword));
Mock.Assert(() => Crypto.Sdk.Crypto.GenerateUserKeyPair(Arg.AnyString));
Mock.Assert(() => CryptoErrorMapper.ParseCause(Arg.IsAny <Exception>()));
}
public void ExecuteWebClientDownload_RequestCancel_Fail()
{
// ARRANGE
Uri uri = new Uri("https://dracoon.team");
Mock.Arrange(() => new WebClient().DownloadDataTaskAsync(uri)).IgnoreInstance().Returns(Mock.Create <Task <byte[]> >());
Mock.Arrange(() => Mock.Create <Task <byte[]> >().Result).IgnoreInstance()
.Throws(new AggregateException(new WebException("Test", WebExceptionStatus.RequestCanceled)));
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock();
IRequestExecutor exec = new DracoonRequestExecutor(FactoryClients.OAuthMock, c);
// ACT - ASSERT
Assert.Throws <ThreadInterruptedException>(() => exec.ExecuteWebClientDownload(new WebClient(), uri, RequestType.GetDownloadChunk));
}
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 DoSyncApiCall_Fail()
{
// ARRANGE
RestResponse response = FactoryRestSharp.RestResponse;
IRestRequest request = FactoryRestSharp.GetServerVersionMock();
Mock.Arrange(() => DracoonClient.HttpConfig).Returns(new DracoonHttpConfig());
Mock.Arrange(() => new RestClient().Execute(request)).IgnoreInstance().Returns(response);
Mock.Arrange(() => DracoonErrorParser.ParseError(response, RequestType.GetServerVersion)).Throws(new DracoonApiException());
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock();
IRequestExecutor exec = new DracoonRequestExecutor(FactoryClients.OAuthMock, c);
// ACT - ASSERT
Assert.Throws <DracoonApiException>(() => exec.DoSyncApiCall <ApiServerVersion>(request, RequestType.GetServerVersion));
}
public void ExecuteWebClientDownload_ProtocolError_Fail()
{
// ARRANGE
Uri uri = new Uri("https://dracoon.team");
WebException we = new WebException("Test", WebExceptionStatus.ProtocolError);
Mock.Arrange(() => new WebClient().DownloadDataTaskAsync(uri)).IgnoreInstance().Returns(Mock.Create <Task <byte[]> >());
Mock.Arrange(() => Mock.Create <Task <byte[]> >().Result).IgnoreInstance().Throws(new AggregateException(we));
Mock.Arrange(() => DracoonErrorParser.ParseError(we, RequestType.GetDownloadChunk))
.Throws(new DracoonApiException(DracoonApiCode.SERVER_UNKNOWN_ERROR));
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock();
IRequestExecutor exec = new DracoonRequestExecutor(FactoryClients.OAuthMock, c);
// ACT - ASSERT
Assert.Throws <DracoonApiException>(() => exec.ExecuteWebClientDownload(new WebClient(), uri, RequestType.GetDownloadChunk));
}
public void ValidateTokenValidity()
{
// ARRANGE
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonAccountImpl a = new DracoonAccountImpl(c);
Mock.Arrange(() => c.Builder.GetAuthenticatedPing()).Returns(FactoryRestSharp.GetAuthenticatedPingMock()).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <VoidResponse>(Arg.IsAny <IRestRequest>(), RequestType.GetAuthenticatedPing, 0)).DoNothing().Occurs(1);
// ACT
a.ValidateTokenValidity();
// ASSERT
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
public void ExecuteWebClientChunkUpload_SecureChannelFailure_Fail()
{
// ARRANGE
byte[] chunk = Encoding.UTF8.GetBytes("OK");
Uri uri = new Uri("https://dracoon.team");
Mock.Arrange(() => new WebClient().UploadDataTaskAsync(uri, "POST", chunk)).IgnoreInstance().Returns(Mock.Create <Task <byte[]> >());
Mock.Arrange(() => Mock.Create <Task <byte[]> >().Result).IgnoreInstance()
.Throws(new AggregateException(new WebException("Test", WebExceptionStatus.SecureChannelFailure)));
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock();
IRequestExecutor exec = new DracoonRequestExecutor(FactoryClients.OAuthMock, c);
// ACT - ASSERT
Assert.Throws <DracoonNetInsecureException>(() =>
exec.ExecuteWebClientChunkUpload(new WebClient(), uri, chunk, RequestType.PostUploadChunk));
}
public void GenerateNewUserKeyPair_Success()
{
// ARRANGE
UserKeyPair expected = FactoryUser.UserKeyPair;
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonAccountImpl a = new DracoonAccountImpl(c);
Mock.Arrange(() => Crypto.Sdk.Crypto.GenerateUserKeyPair(Arg.AnyString)).Returns(FactoryUser.UserKeyPair).Occurs(1);
// ACT
UserKeyPair actual = a.GenerateNewUserKeyPair(c.EncryptionPassword);
// ASSERT
Assert.Equal(expected, actual, new UserKeyPairComparer());
Mock.Assert(() => Crypto.Sdk.Crypto.GenerateUserKeyPair(Arg.AnyString));
}
public void DeleteUserKeyPair()
{
// ARRANGE
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonAccountImpl a = new DracoonAccountImpl(c);
Mock.Arrange(() => c.Builder.DeleteUserKeyPair()).Returns(FactoryRestSharp.DeleteUserKeyPairMock()).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <VoidResponse>(Arg.IsAny <IRestRequest>(), RequestType.DeleteUserKeyPair, 0)).DoNothing().Occurs(1);
// ACT
a.DeleteUserKeyPair();
// ASSERT
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
public void ExecuteWebClientChunkUpload_Success()
{
// ARRANGE
byte[] expected = Encoding.UTF8.GetBytes("OK");
Uri uri = new Uri("https://dracoon.team");
Mock.Arrange(() => new WebClient().UploadDataTaskAsync(uri, "POST", expected)).IgnoreInstance().Returns(Mock.Create <Task <byte[]> >());
Mock.Arrange(() => Mock.Create <Task <byte[]> >().Result).IgnoreInstance().Returns(expected);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock();
IRequestExecutor exec = new DracoonRequestExecutor(FactoryClients.OAuthMock, c);
// ACT
byte[] actual = exec.ExecuteWebClientChunkUpload(new WebClient(), uri, expected, RequestType.PostUploadChunk);
// ASSERT
Assert.Equal(expected, actual);
}
public void CheckUserKeyPairPassword_Success()
{
// ARRANGE
bool expected = true;
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonAccountImpl a = new DracoonAccountImpl(c);
Mock.Arrange(() => a.GetAndCheckUserKeyPair()).Returns(FactoryUser.UserKeyPair).Occurs(1);
// ACT
bool actual = a.CheckUserKeyPairPassword();
// ASSERT
Assert.Equal(expected, actual);
Mock.Assert(a);
Mock.Assert(c.Executor);
}
public void CheckUserKeyPairPassword_WrongPassword()
{
// ARRANGE
bool expected = false;
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonAccountImpl a = new DracoonAccountImpl(c);
Mock.Arrange(() => a.GetAndCheckUserKeyPair()).Throws(new DracoonCryptoException(DracoonCryptoCode.INVALID_PASSWORD_ERROR)).Occurs(1);
// ACT
bool actual = a.CheckUserKeyPairPassword();
// ASSERT
Assert.Equal(expected, actual);
Mock.Assert(a);
Mock.Assert(c.Executor);
}
public void CreateUploadShare()
{
// ARRANGE
CreateUploadShareRequest req = FactoryShare.CreateUploadShareRequest;
req.EmailRecipients = new List <string> {
"985678"
};
req.EmailBody = "Any body!";
req.EmailSubject = "Any subject!";
req.SmsRecipients = new List <string> {
"28436054"
};
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonSharesImpl s = new DracoonSharesImpl(c);
Mock.Arrange(() => Arg.IsAny <CreateUploadShareRequest>().MustNotNull(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.AnyLong.MustPositive(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool)).DoNothing().OccursAtLeast(1);
Mock.Arrange(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString)).DoNothing().Occurs(2);
Mock.Arrange(() => Arg.IsAny <long?>().NullableMustPositive(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.IsAny <IEnumerable <string> >().EnumerableMustNotNullOrEmpty(Arg.AnyString)).DoNothing();
Mock.Arrange(() => ShareMapper.ToApiCreateUploadShareRequest(Arg.IsAny <CreateUploadShareRequest>()))
.Returns(FactoryShare.ApiCreateUploadShareRequest).Occurs(1);
Mock.Arrange(() => c.Builder.PostCreateUploadShare(Arg.IsAny <ApiCreateUploadShareRequest>())).Returns(FactoryRestSharp.PostCreateUploadShareMock()).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadShare>(Arg.IsAny <IRestRequest>(), RequestType.PostCreateUploadShare, 0))
.Returns(FactoryShare.ApiUploadShare).Occurs(1);
Mock.Arrange(() => ShareMapper.FromApiUploadShare(Arg.IsAny <ApiUploadShare>())).Returns(FactoryShare.UploadShare).Occurs(1);
// ACT
UploadShare actual = s.CreateUploadShare(req);
// ASSERT
Assert.NotNull(actual);
Mock.Assert(() => Arg.IsAny <CreateUploadShareRequest>().MustNotNull(Arg.AnyString));
Mock.Assert(() => Arg.AnyLong.MustPositive(Arg.AnyString));
Mock.Assert(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool));
Mock.Assert(() => Arg.IsAny <int?>().NullableMustPositive(Arg.AnyString));
Mock.Assert(() => Arg.IsAny <long?>().NullableMustPositive(Arg.AnyString));
Mock.Assert(() => Arg.IsAny <IEnumerable <string> >().EnumerableMustNotNullOrEmpty(Arg.AnyString));
Mock.Assert(() => ShareMapper.ToApiCreateUploadShareRequest(Arg.IsAny <CreateUploadShareRequest>()));
Mock.Assert(() => ShareMapper.FromApiUploadShare(Arg.IsAny <ApiUploadShare>()));
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
public void GetUserAvatar()
{
// ARRANGE
Bitmap image = new Bitmap(50, 50);
Graphics imageData = Graphics.FromImage(image);
imageData.DrawLine(new Pen(Color.Red), 0, 0, 50, 50);
MemoryStream memoryStream = new MemoryStream();
byte[] bitmapData;
using (memoryStream) {
image.Save(memoryStream, ImageFormat.Bmp);
bitmapData = memoryStream.ToArray();
}
long id = 5;
string uuid = "H7D68J";
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
DracoonUsersImpl u = new DracoonUsersImpl(c);
Mock.Arrange(() => Arg.AnyLong.MustPositive(Arg.AnyString)).DoNothing().Occurs(1);
Mock.Arrange(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool)).DoNothing().Occurs(1);
Mock.Arrange(() => c.Builder.GetUserAvatar(Arg.AnyLong, Arg.AnyString)).Returns(FactoryRestSharp.GetUserAvatarMock()).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiAvatarInfo>(Arg.IsAny <IRestRequest>(), RequestType.GetResourcesAvatar, 0))
.Returns(FactoryUser.ApiAvatarInfo).Occurs(1);
Mock.Arrange(() => c.Builder.ProvideAvatarDownloadWebClient()).Returns(() => {
DracoonWebClientExtension wc = new DracoonWebClientExtension();
wc.Headers.Add(HttpRequestHeader.UserAgent, new DracoonHttpConfig().UserAgent);
wc.SetHttpConfigParams(new DracoonHttpConfig());
return(wc);
}).Occurs(1);
Mock.Arrange(() => c.Executor.ExecuteWebClientDownload(Arg.IsAny <WebClient>(), Arg.IsAny <Uri>(), RequestType.GetResourcesAvatar, null, 0))
.Returns(bitmapData).Occurs(1);
// ACT
Image actual = u.GetUserAvatar(id, uuid);
// ASSERT
Assert.NotNull(actual);
Mock.Assert(() => Arg.AnyLong.MustPositive(Arg.AnyString));
Mock.Assert(() => Arg.AnyString.MustNotNullOrEmptyOrWhitespace(Arg.AnyString, Arg.AnyBool));
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
