public void Public_GetServerVersion()
        {
            // ARRANGE
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            IRestRequest    expected = FactoryClients.RequestBuilderMock.GetServerVersion();

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

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void User_GetAuthenticatedPing()
        {
            // ARRANGE
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            IRestRequest    expected = FactoryClients.RequestBuilderMock.GetAuthenticatedPing();

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

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void User_ProvideAvatarDownloadWebClient()
        {
            // ARRANGE
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            WebClient       expected = FactoryClients.RequestBuilderMock.ProvideAvatarDownloadWebClient();

            // ACT
            WebClient actual = builder.ProvideAvatarDownloadWebClient();

            // ASSERT
            Assert.Equal(expected, actual, new WebClientComparer());
        }
        public void User_DeleteUserKeyPair()
        {
            // ARRANGE
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            IRestRequest    expected = FactoryClients.RequestBuilderMock.DeleteUserKeyPair();

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

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        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());
        }
        public void Nodes_GetS3Status()
        {
            // ARRANGE
            string          uploadId = "GH6D5";
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            IRestRequest    expected = FactoryClients.RequestBuilderMock.GetS3Status(uploadId);

            // ACT
            IRestRequest actual = builder.GetS3Status(uploadId);

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_GetFileKey()
        {
            // ARRANGE
            long            id       = 2;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            IRestRequest    expected = FactoryClients.RequestBuilderMock.GetFileKey(id);

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

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        public void Nodes_GetNodes_NoFilter()
        {
            // ARRANGE
            long            id = 5, offset = 3, limit = 2;
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            IRestRequest    expected = FactoryClients.RequestBuilderMock.GetNodes(id, offset, limit);

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

            // 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_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 User_ProvideAvatarUploadWebClient()
        {
            // ARRANGE
            string          data     = "some test data!";
            IOAuth          auth     = FactoryClients.OAuthMock;
            IRequestBuilder builder  = new DracoonRequestBuilder(auth);
            WebClient       expected = FactoryClients.RequestBuilderMock.ProvideAvatarUploadWebClient(data);

            // ACT
            WebClient actual = builder.ProvideAvatarUploadWebClient(data);

            // ASSERT
            Assert.Equal(expected, actual, new WebClientComparer());
        }
        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_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_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_GetNodes()
        {
            // ARRANGE
            long           id = 5, offset = 3, limit = 2;
            GetNodesFilter f = new GetNodesFilter();

            f.AddNodeIsEncryptedFilter(GetNodesFilter.IsEncrypted.EqualTo(true).Build());
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            IRestRequest    expected = FactoryClients.RequestBuilderMock.GetNodes(id, offset, limit, f);

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

            // 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_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_ProvideS3ChunkUploadWebClient()
        {
            // ARRANGE
            DracoonHttpConfig         conf     = new DracoonHttpConfig();
            IRequestBuilder           builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            DracoonWebClientExtension expected = new DracoonWebClientExtension();

            expected.Headers.Add(HttpRequestHeader.UserAgent, conf.UserAgent);
            expected.SetHttpConfigParams(conf);

            // ACT
            WebClient actual = builder.ProvideS3ChunkUploadWebClient();

            // ASSERT
            Assert.Equal(expected, actual, new WebClientComparer());
        }
        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 OAuth_PostOAuthRefresh()
        {
            // ARRANGE
            string          clientId = "GS36SG653FDAY", clientSecret = "H7BD5D6G56", grand = "pw", refreshToken = "things";
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected = FactoryRestSharp.RestRequestWithoutAuth(OAuthConfig.OAuthPostRefreshToken, Method.POST);

            expected.AddHeader("Authorization", "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(clientId + ":" + clientSecret)));
            expected.AddParameter("grant_type", grand, ParameterType.GetOrPost);
            expected.AddParameter("refresh_token", refreshToken, ParameterType.GetOrPost);

            // ACT
            IRestRequest actual = builder.PostOAuthRefresh(clientId, clientSecret, grand, refreshToken);

            // 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 Resources_GetUserAvatar()
        {
            // ARRANGE
            string          avatarUuid = "JG7DM2DZ6";
            long            userId     = 167890;
            IRequestBuilder builder    = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            RestRequest     expected   = FactoryRestSharp.RestRequestWithoutAuth(ApiConfig.ApiResourcesGetAvatar, Method.GET);

            expected.AddUrlSegment("userId", userId);
            expected.AddUrlSegment("uuid", avatarUuid);

            // ACT
            IRestRequest actual = builder.GetUserAvatar(userId, avatarUuid);

            // 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 Nodes_GetSearchNodes()
        {
            // ARRANGE
            string            searchString = "test";
            long              parent = 234, offset = 2, limit = 3;
            int               depth = 1;
            SearchNodesFilter f     = new SearchNodesFilter();

            f.AddIsFavoriteFilter(SearchNodesFilter.IsFavorite.EqualTo(true).Build());
            SearchNodesSort s        = SearchNodesSort.Name.Ascending();
            IRequestBuilder builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            IRestRequest    expected = FactoryClients.RequestBuilderMock.GetSearchNodes(parent, searchString, offset, limit, depth, f, s);

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

            // ASSERT
            Assert.Equal(expected, actual, new RestRequestComparer());
        }
        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_ProvideChunkUploadWebClient()
        {
            // ARRANGE
            int                       length = 54637;
            long                      offset = 5;
            string                    data = "someDataThings!", fileSize = "123";
            DracoonHttpConfig         conf     = new DracoonHttpConfig();
            IRequestBuilder           builder  = new DracoonRequestBuilder(FactoryClients.OAuthMock);
            DracoonWebClientExtension expected = new DracoonWebClientExtension();

            expected.Headers.Add(HttpRequestHeader.ContentRange, "bytes " + offset + "-" + (offset + length) + "/" + fileSize);
            expected.Headers.Add(HttpRequestHeader.ContentType, "multipart/form-data; boundary=" + data);
            expected.Headers.Add(HttpRequestHeader.UserAgent, conf.UserAgent);
            expected.SetHttpConfigParams(conf);

            // ACT
            WebClient actual = builder.ProvideChunkUploadWebClient(length, offset, data, fileSize);

            // ASSERT
            Assert.Equal(expected, actual, new WebClientComparer());
        }
        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());
        }