예제 #1
0
        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();
        }
예제 #2
0
        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();
        }
예제 #3
0
        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 Config_GetDefaultsSettings()
        {
            // ARRANGE
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetDefaultsConfig, Method.GET);

            // ACT
            IRestRequest actual = builder.GetDefaultsSettings();

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
예제 #5
0
        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 Nodes_PostMissingFileKeys()
        {
            // ARRANGE
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiPostMissingFileKeys, Method.POST);

            expected.AddParameter("application/json", JsonConvert.SerializeObject(FactoryFile.ApiSetUserFileKeysRequest), ParameterType.RequestBody);

            // ACT
            IRestRequest actual = builder.PostMissingFileKeys(FactoryFile.ApiSetUserFileKeysRequest);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_DeleteNodes()
        {
            // ARRANGE
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiDeleteNodes, Method.DELETE);

            expected.AddParameter("application/json", JsonConvert.SerializeObject(FactoryNode.ApiDeleteNodesRequest), ParameterType.RequestBody);

            // ACT
            IRestRequest actual = builder.DeleteNodes(FactoryNode.ApiDeleteNodesRequest);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_GetPreviousVersion()
        {
            // ARRANGE
            long            id       = 78654;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetPreviousVersion, Method.GET);

            expected.AddUrlSegment("previousNodeId", id);

            // ACT
            IRestRequest actual = builder.GetPreviousVersion(id);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_PutCompleteFileUpload()
        {
            // ARRANGE
            string          path     = "some/dummy/path";
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(path, Method.PUT);

            expected.AddParameter("application/json", JsonConvert.SerializeObject(FactoryFile.ApiCompleteFileUpload), ParameterType.RequestBody);

            // ACT
            IRestRequest actual = builder.PutCompleteFileUpload(path, FactoryFile.ApiCompleteFileUpload);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_PostFavorite()
        {
            // ARRANGE
            long            id       = 168;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiPostFavorite, Method.POST);

            expected.AddUrlSegment("nodeId", id);

            // ACT
            IRestRequest actual = builder.PostFavorite(id);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Shares_DeleteUploadShare()
        {
            // ARRANGE
            long            id       = 893756;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiDeleteUploadShare, Method.DELETE);

            expected.AddUrlSegment("shareId", id);

            // ACT
            IRestRequest actual = builder.DeleteUploadShare(id);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_DeleteRecycleBin()
        {
            // ARRANGE
            long            id       = 39468345;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiDeleteRecycleBin, Method.DELETE);

            expected.AddUrlSegment("roomId", id);

            // ACT
            IRestRequest actual = builder.DeleteRecycleBin(id);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_PutCompleteS3FileUpload()
        {
            // ARRANGE
            string          uploadId = "GH6D5";
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiPutCompleteS3Upload, Method.PUT);

            expected.AddParameter("application/json", JsonConvert.SerializeObject(FactoryFile.ApiCompleteS3FileUpload), ParameterType.RequestBody);
            expected.AddUrlSegment("uploadId", uploadId);

            // ACT
            IRestRequest actual = builder.PutCompleteS3FileUpload("GH6D5", FactoryFile.ApiCompleteS3FileUpload);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_PostMoveNodes()
        {
            // ARRANGE
            long            id       = 8790;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiPostMoveNodes, Method.POST);

            expected.AddParameter("application/json", JsonConvert.SerializeObject(FactoryNode.ApiMoveNodesRequest), ParameterType.RequestBody);
            expected.AddUrlSegment("nodeId", id);

            // ACT
            IRestRequest actual = builder.PostMoveNodes(id, FactoryNode.ApiMoveNodesRequest);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Shares_GetUploadShares_NoFilter_NoSort()
        {
            // ARRANGE
            long            offset = 4, limit = 5;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetUploadShares, Method.GET);

            expected.AddQueryParameter("offset", offset.ToString());
            expected.AddQueryParameter("limit", limit.ToString());

            // ACT
            IRestRequest actual = builder.GetUploadShares(offset, limit);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_PutFile()
        {
            // ARRANGE
            long            id       = 567;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiPutFileUpdate, Method.PUT);

            expected.AddParameter("application/json", JsonConvert.SerializeObject(FactoryFile.ApiUpdateFileRequest), ParameterType.RequestBody);
            expected.AddUrlSegment("fileId", id);

            // ACT
            IRestRequest actual = builder.PutFile(id, FactoryFile.ApiUpdateFileRequest);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_GetRecycleBin()
        {
            // ARRANGE
            long            id = 567, offset = 4, limit = 5;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetRecycleBin, Method.GET);

            expected.AddUrlSegment("roomId", id);
            expected.AddQueryParameter("offset", offset.ToString());
            expected.AddQueryParameter("limit", limit.ToString());

            // ACT
            IRestRequest actual = builder.GetRecycleBin(id, offset, limit);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_GetMissingFileKeys()
        {
            // ARRANGE
            long            id = 346;
            int             offset = 2, limit = 3;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetMissingFileKeys, Method.GET);

            expected.AddQueryParameter("fileId", id.ToString());
            expected.AddQueryParameter("offset", offset.ToString());
            expected.AddQueryParameter("limit", limit.ToString());

            // ACT
            IRestRequest actual = builder.GetMissingFileKeys(id, limit, offset);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void GetGeneral()
        {
            // ARRANGE
            ServerGeneralSettings     expected = FactoryServerSettings.ServerGeneralSettings;
            IInternalDracoonClient    c        = FactoryClients.InternalDracoonClientMock(true);
            DracoonServerSettingsImpl ss       = new DracoonServerSettingsImpl(c);

            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(() => SettingsMapper.FromApiGeneralSettings(Arg.IsAny <ApiGeneralSettings>())).Returns(FactoryServerSettings.ServerGeneralSettings).Occurs(1);

            // ACT
            ServerGeneralSettings actual = ss.GetGeneral();

            // ASSERT
            Assert.Equal(expected, actual, new ServerGeneralSettingsComparer());
            Mock.Assert(() => SettingsMapper.FromApiGeneralSettings(Arg.IsAny <ApiGeneralSettings>()));
            Mock.Assert(c.Executor);
            Mock.Assert(c.Builder);
        }
        public void Nodes_GetSearchNodes_NoFilter_NoSort()
        {
            // ARRANGE
            string          searchString = "test";
            long            parent = 234, offset = 2, limit = 3;
            int             depth    = 1;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetSearchNodes, Method.GET);

            expected.AddQueryParameter("search_string", searchString);
            expected.AddQueryParameter("parent_id", parent.ToString());
            expected.AddQueryParameter("depth_level", depth.ToString());
            expected.AddQueryParameter("offset", offset.ToString());
            expected.AddQueryParameter("limit", limit.ToString());

            // ACT
            IRestRequest actual = builder.GetSearchNodes(parent, searchString, offset, limit, depth);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_GetPreviousVersions()
        {
            // ARRANGE
            string          type = "room", name = "testRoom";
            long            id = 34567;
            int             offset = 7, limit = 3;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetPreviousVersions, Method.GET);

            expected.AddUrlSegment("nodeId", id);
            expected.AddQueryParameter("type", type);
            expected.AddQueryParameter("name", name);
            expected.AddQueryParameter("offset", offset.ToString());
            expected.AddQueryParameter("limit", limit.ToString());

            // ACT
            IRestRequest actual = builder.GetPreviousVersions(id, type, name, offset, limit);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Shares_GetUploadShares()
        {
            // ARRANGE
            string          fString = "name:cn:name_part_up", sString = "name:desc";
            long            offset = 4, limit = 5;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetUploadShares, Method.GET);

            expected.AddQueryParameter("filter", fString);
            expected.AddQueryParameter("sort", sString);
            expected.AddQueryParameter("offset", offset.ToString());
            expected.AddQueryParameter("limit", limit.ToString());

            // ACT
            GetUploadSharesFilter f = new GetUploadSharesFilter();

            f.AddNameFilter(GetUploadSharesFilter.Name.Contains("name_part_up").Build());
            IRestRequest actual = builder.GetUploadShares(offset, limit, f, SharesSort.Name.Descending());

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
예제 #23
0
        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);
        }
예제 #24
0
        public void Encrypted_RunSync_S3_KnownFileSize_Success()
        {
            // ARRANGE
            byte[] fileMock = new byte[1564];
            new Random().NextBytes(fileMock);
            Stream s = new MemoryStream(fileMock);
            IInternalDracoonClient c        = FactoryClients.InternalDracoonClientMock(true);
            FileUploadCallbackMock callback = new FileUploadCallbackMock();
            EncFileUpload          f        = new EncFileUpload(c, "id1", FactoryFile.UploadFileRequest, s, FactoryUser.UserPublicKey, fileMock.Length);

            f.AddFileUploadCallback(callback);
            ApiGeneralSettings generalSettings = FactoryServerSettings.ApiGeneralSettings;

            generalSettings.UseS3Storage = true;
            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.PutCompleteS3FileUpload(Arg.AnyString, Arg.IsAny <ApiCompleteFileUpload>()))
            .Returns(FactoryRestSharp.PutCompleteFileUploadMock("path")).Occurs(1);
            Mock.Arrange(() => c.Executor.DoSyncApiCall <VoidResponse>(Arg.IsAny <IRestRequest>(), RequestType.PutCompleteS3Upload, 0)).DoNothing()
            .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(generalSettings).Occurs(1);
            Mock.Arrange(() => c.Builder.PostGetS3Urls(Arg.AnyString, Arg.IsAny <ApiGetS3Urls>())).Returns(FactoryRestSharp.PostGetS3UrlsMock())
            .OccursAtLeast(1);
            Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiS3Urls>(Arg.IsAny <IRestRequest>(), RequestType.PostGetS3Urls, 0))
            .Returns(FactoryFile.ApiS3Urls).OccursAtLeast(1);
            Mock.Arrange(() => c.Builder.GetS3Status(Arg.AnyString)).Returns(FactoryRestSharp.GetS3StatusMock).OccursAtLeast(1);
            Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiS3Status>(Arg.IsAny <IRestRequest>(), RequestType.GetS3Status, 0))
            .Returns(FactoryFile.ApiS3Status).OccursAtLeast(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(() => FileMapper.ToApiCompleteFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(FactoryFile.ApiCompleteFileUpload);
            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.PutUploadS3Chunk, 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.ProvideS3ChunkUploadWebClient()).Returns(wc);
            Mock.Arrange(() => JsonConvert.DeserializeObject <ApiUploadChunkResult>(Arg.AnyString)).Returns(FactoryFile.ApiUploadChunkResult);

            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.Arrange(() => Crypto.Sdk.Crypto.EncryptFileKey(Arg.IsAny <PlainFileKey>(), Arg.IsAny <UserPublicKey>()))
            .Returns(FactoryFile.EncryptedFileKey).Occurs(1);
            Mock.Arrange(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>())).Returns(FactoryFile.ApiFileKey);

            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);
        }
예제 #25
0
        public void RunSync_S3_PollingError()
        {
            // ARRANGE
            ApiS3Status resultStatus = FactoryFile.ApiS3Status;

            resultStatus.Node      = null;
            resultStatus.Status    = "error";
            resultStatus.ErrorInfo = null;
            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);
            ApiGeneralSettings generalSettings = FactoryServerSettings.ApiGeneralSettings;

            generalSettings.UseS3Storage = true;
            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.PutCompleteS3FileUpload(Arg.AnyString, Arg.IsAny <ApiCompleteFileUpload>()))
            .Returns(FactoryRestSharp.PutCompleteFileUploadMock("path")).Occurs(1);
            Mock.Arrange(() => c.Executor.DoSyncApiCall <VoidResponse>(Arg.IsAny <IRestRequest>(), RequestType.PutCompleteS3Upload, 0)).DoNothing()
            .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(generalSettings).Occurs(1);
            Mock.Arrange(() => c.Builder.PostGetS3Urls(Arg.AnyString, Arg.IsAny <ApiGetS3Urls>())).Returns(FactoryRestSharp.PostGetS3UrlsMock())
            .OccursAtLeast(1);
            Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiS3Urls>(Arg.IsAny <IRestRequest>(), RequestType.PostGetS3Urls, 0))
            .Returns(FactoryFile.ApiS3Urls).OccursAtLeast(1);
            Mock.Arrange(() => c.Builder.GetS3Status(Arg.AnyString)).Returns(FactoryRestSharp.GetS3StatusMock).OccursAtLeast(1);
            Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiS3Status>(Arg.IsAny <IRestRequest>(), RequestType.GetS3Status, 0)).Returns(resultStatus)
            .OccursAtLeast(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(() => FileMapper.ToApiCompleteFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(FactoryFile.ApiCompleteFileUpload);
            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.PutUploadS3Chunk, 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.ProvideS3ChunkUploadWebClient()).Returns(wc);
            Mock.Arrange(() => JsonConvert.DeserializeObject <ApiUploadChunkResult>(Arg.AnyString)).Returns(FactoryFile.ApiUploadChunkResult);
            Mock.Arrange(() => DracoonErrorParser.ParseError(Arg.IsAny <ApiErrorResponse>(), RequestType.GetS3Status)).DoNothing();

            Mock.Arrange(() => callback.OnStarted(Arg.AnyString)).Occurs(1);
            Mock.Arrange(() => callback.OnRunning(Arg.AnyString, Arg.AnyLong, Arg.AnyLong)).OccursAtLeast(1);
            Mock.Arrange(() => callback.OnFailed(Arg.AnyString, Arg.IsAny <DracoonException>())).Occurs(1);

            // ACT
            Assert.Throws <DracoonApiException>(() => f.RunSync());
            s.Close();

            // ASSERT
            Mock.Assert(callback);
            Mock.Assert(c.Builder);
            Mock.Assert(c.Executor);
        }