public async Task ListGroups_WhenFilterIsSpecified_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
ListGroupsResponseContent,
Encoding.UTF8,
"application/json")
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var userList = await egnyteClient.Groups.ListGroups(1, 10, @"displayname co ""ccou""");
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v2/groups?startIndex=1&count=10&filter=displayname co \"ccou\"",
requestMessage.RequestUri.ToString());
Assert.AreEqual(2, userList.TotalResults);
Assert.AreEqual(10, userList.ItemsPerPage);
Assert.AreEqual(5, userList.StartIndex);
Assert.AreEqual(2, userList.Resources.Count);
}
public async Task GetEffectiveUserPermissions_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("{ \"permission\": \"Owner\" }")
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var permissions = await egnyteClient.Permissions.GetEffectivePermissionsForUser(
"mjones", "Shared/myFolder");
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v1/perms/user/mjones?folder=/Shared/myFolder",
requestMessage.RequestUri.ToString());
Assert.AreEqual(HttpMethod.Get, requestMessage.Method);
Assert.AreEqual(PermissionType.Owner, permissions);
}
public async Task ListTasks_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
ListTasksResponseContent,
Encoding.UTF8,
"application/json")
});
var firstExpectedTask = GetTaskDetailsTests.GetCreatedTask();
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var tasksList = await egnyteClient.Tasks.ListTasks(firstExpectedTask.File.GroupId);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v1/tasks?groupId=" + firstExpectedTask.File.GroupId,
requestMessage.RequestUri.ToString());
Assert.AreEqual(2, tasksList.Count);
Assert.AreEqual(2, tasksList.Tasks.Count);
GetTaskDetailsTests.AssertTasksEqual(firstExpectedTask, tasksList.Tasks.First());
}
public async Task DeleteFolder_WithEntryId_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(string.Empty)
});
var entryId = "9355165a-e599-4148-88c5-0d3552493e2f";
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var isSucccess = await egnyteClient.Files.DeleteFileOrFolder("path", entryId);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
var content = httpHandlerMock.GetRequestContentAsString();
Assert.IsTrue(isSucccess);
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v1/fs/path?entry_id=" + entryId,
requestMessage.RequestUri.ToString());
Assert.IsNull(content);
}
public async Task DownloadFile_WithoutContentRange_ReturnsCorrectFile()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) => Task.FromResult(GetResponseWithoutContentRangeMessage());
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var result = await egnyteClient.Files.DownloadFile("myFile").ConfigureAwait(false);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(3, result.Data.Length);
Assert.AreEqual(0x20, result.Data[0]);
Assert.AreEqual(0x21, result.Data[1]);
Assert.AreEqual(0x22, result.Data[2]);
Assert.AreEqual(Checksum, result.Checksum);
Assert.AreEqual(new DateTime(2012, 08, 26, 5, 55, 29), result.LastModified);
Assert.AreEqual("\"" + ETag + "\"", result.ETag);
Assert.AreEqual(ContentType, result.ContentType);
Assert.AreEqual(ContentLength, result.ContentLength);
Assert.AreEqual(0, result.FullFileLength);
Assert.AreEqual("https://acme.egnyte.com/pubapi/v1/fs-content/myFile", requestMessage.RequestUri.ToString());
}
public async Task GetTaskDetails_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
CreatedTaskResponse,
Encoding.UTF8,
"application/json")
});
var expectedTask = GetCreatedTask();
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var taskDetails = await egnyteClient.Tasks.GetTaskDetails(expectedTask.Id);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v1/tasks/" + expectedTask.Id,
requestMessage.RequestUri.ToString());
AssertTasksEqual(expectedTask, taskDetails);
}
public async Task GetUserList_WhenFilterIsSpecified_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
GetUserListResponseContent,
Encoding.UTF8,
"application/json")
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var userList = await egnyteClient.Users.GetUserList(1, 10, "email eq \"[email protected]\"");
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v2/users?startIndex=1&count=10&filter=email eq \"[email protected]\"",
requestMessage.RequestUri.ToString());
Assert.AreEqual(100, userList.TotalResults);
Assert.AreEqual(2, userList.ItemsPerPage);
Assert.AreEqual(6, userList.StartIndex);
Assert.AreEqual(2, userList.Users.Count);
}
public async Task DownloadFile_WithRange_ReturnsCorrectFile()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) => Task.FromResult(GetResponseMessage());
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var result = await egnyteClient.Files.DownloadFile("myFile", new Range(0, 100))
.ConfigureAwait(false);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
var rangeHeaders = requestMessage.Headers.GetValues("Range").ToArray();
Assert.AreEqual(1, rangeHeaders.Length);
Assert.AreEqual("bytes=0-100", rangeHeaders[0]);
Assert.AreEqual(3, result.Data.Length);
Assert.AreEqual(0x20, result.Data[0]);
Assert.AreEqual(0x21, result.Data[1]);
Assert.AreEqual(0x22, result.Data[2]);
Assert.AreEqual(Checksum, result.Checksum);
Assert.AreEqual(new DateTime(2012, 08, 26, 5, 55, 29), result.LastModified);
Assert.AreEqual("\"" + ETag + "\"", result.ETag);
Assert.AreEqual(ContentType, result.ContentType);
Assert.AreEqual(ContentLength, result.ContentLength);
Assert.AreEqual(999, result.FullFileLength);
}
public async Task ListLinksV2_WithAllParameters_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
ListLinksResponseContent,
Encoding.UTF8,
"application/json")
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var linksList = await egnyteClient.Links.ListLinksV2(
"shared/",
"johnd",
new DateTime(2016, 05, 01),
new DateTime(2016, 01, 01),
Api.Links.LinkType.Folder,
Api.Links.LinkAccessibility.Recipients,
100,
15);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
@"https://acme.egnyte.com/pubapi/v2/links?path=shared/&username=johnd&created_before=2016-05-01&created_after=2016-01-01&type=folder&accessibility=recipients&offset=100&count=15",
requestMessage.RequestUri.ToString());
}
public async Task DeleteGroup_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(string.Empty)
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var isSucccess = await egnyteClient.Groups.DeleteGroup("myGroup");
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
var content = httpHandlerMock.GetRequestContentAsString();
Assert.IsTrue(isSucccess);
Assert.AreEqual(HttpMethod.Delete, requestMessage.Method);
Assert.AreEqual("https://acme.egnyte.com/pubapi/v2/groups/myGroup", requestMessage.RequestUri.ToString());
Assert.IsNull(content);
}
public async Task CreateTask_WithoutRequiredFieldsSpecified_ThrowsException()
{
var httpClient = new HttpClient(new HttpMessageHandlerMock());
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var newTask = GetNewTask();
newTask.Task = null;
var exception = await AssertExtensions.ThrowsAsync <ArgumentException>(
() => egnyteClient.Tasks.CreateTask(newTask));
Assert.IsTrue(exception.Message.Contains(nameof(newTask.Task)));
Assert.IsNull(exception.InnerException);
newTask = GetNewTask();
newTask.File = null;
exception = await AssertExtensions.ThrowsAsync <ArgumentException>(
() => egnyteClient.Tasks.CreateTask(newTask));
Assert.IsTrue(exception.Message.Contains(nameof(newTask.File)));
Assert.IsNull(exception.InnerException);
newTask = GetNewTask();
newTask.Assignees = null;
exception = await AssertExtensions.ThrowsAsync <ArgumentException>(
() => egnyteClient.Tasks.CreateTask(newTask));
Assert.IsTrue(exception.Message.Contains(nameof(newTask.Assignees)));
Assert.IsNull(exception.InnerException);
}
public async Task CreateTask_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.Created,
Content = new StringContent(
GetTaskDetailsTests.CreatedTaskResponse,
Encoding.UTF8,
"application/json")
});
var expectedTask = GetTaskDetailsTests.GetCreatedTask();
var newTask = GetNewTask(expectedTask);
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var createdTask = await egnyteClient.Tasks.CreateTask(newTask);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual("https://acme.egnyte.com/pubapi/v1/tasks", requestMessage.RequestUri.ToString());
var content = httpHandlerMock.GetRequestContentAsString();
Assert.AreEqual(
TestsHelper.RemoveWhitespaces(CreateTaskRequestContent),
TestsHelper.RemoveWhitespaces(content));
GetTaskDetailsTests.AssertTasksEqual(expectedTask, createdTask);
}
public async Task SetTaskStatus_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK
});
var createdTask = GetTaskDetailsTests.GetCreatedTask();
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var updatedTask = await egnyteClient.Tasks.SetTaskStatus(createdTask.Id, Api.Tasks.TaskStatus.Completed);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v1/tasks/" + createdTask.Id,
requestMessage.RequestUri.ToString());
var content = httpHandlerMock.GetRequestContentAsString();
Assert.AreEqual(
TestsHelper.RemoveWhitespaces(ChangeStatusRequestContent),
TestsHelper.RemoveWhitespaces(content));
}
public async Task CreateFolder_ReturnsSuccess()
{
var folderId = "1ff2c7b3-3d97-4c22-982c-8505d137f089";
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.Created,
Content = new StringContent("{\"folder_id\":\"" + folderId + "\"}")
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var response = await egnyteClient.Files.CreateFolder("path");
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
var content = httpHandlerMock.GetRequestContentAsString();
Assert.AreEqual(folderId, response.FolderId);
Assert.AreEqual("https://acme.egnyte.com/pubapi/v1/fs/path", requestMessage.RequestUri.ToString());
Assert.AreEqual("{\"action\": \"add_folder\"}", content);
}
public async Task GetFolderPermissions_WhenResponseContainsNoUsers_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(GetFolderPermissionsResponseContentV2_NoUsers)
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var folderPermissions = await egnyteClient.Permissions.GetFolderPermissionsV2("Shared/myFolder");
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v2/perms/Shared/myFolder",
requestMessage.RequestUri.ToString());
Assert.AreEqual(HttpMethod.Get, requestMessage.Method);
Assert.AreEqual(0, folderPermissions.Users.Count);
Assert.AreEqual(1, folderPermissions.Groups.Count);
var group = folderPermissions.Groups.FirstOrDefault(g => g.Subject == "All Administrators");
Assert.IsNotNull(group);
Assert.AreEqual(PermissionType.Owner, group.Permission);
Assert.AreEqual(true, folderPermissions.InheritsPermissions);
}
public async Task ChunkedUploadLastChunk_ReturnsCorrectResponse()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc = (request, cancellationToken) => Task.FromResult(GetLastResponseMessage());
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var result = await egnyteClient.Files.ChunkedUploadLastChunk(
"path",
4,
UploadId,
new MemoryStream(Encoding.UTF8.GetBytes("file")));
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
var content = httpHandlerMock.GetRequestContentAsString();
Assert.AreEqual(Checksum, result.Checksum);
Assert.AreEqual("\"" + ETag + "\"", result.EntryId);
Assert.AreEqual(new DateTime(2012, 08, 26, 5, 55, 29), result.LastModified);
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v1/fs-content-chunked/path",
requestMessage.RequestUri.ToString());
Assert.AreEqual("file", content);
}
public async Task SetFolderPermissions_WithInheritsPermissionsAndKeepParentPermissions_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(string.Empty)
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var userList = await egnyteClient.Permissions.SetFolderPermissionsV2(
"Shared/myFolder/",
inheritsPermissions : false,
keepParentPermissions : true);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v2/perms/Shared/myFolder/",
requestMessage.RequestUri.ToString());
Assert.AreEqual(HttpMethod.Post, requestMessage.Method);
var content = httpHandlerMock.GetRequestContentAsString();
Assert.AreEqual(
TestsHelper.RemoveWhitespaces(SetFolderPermissionsWithInheritsPermissionsAndKeepParentPermissionsRequestContent),
TestsHelper.RemoveWhitespaces(content));
}
public async Task UpdateFileOrFolderCustomMetadata_ForFile_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(UpdateFileCustomMetadataResponse)
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var response = await egnyteClient.Files.UpdateFileOrFolderCustomMetadata(
"path",
"custom attributes",
new FileOrFolderCustomMetadataProperties
{
{ "reviewed", false },
{ "contentType", "application/vnd.openxmlformats-officedocument.wordprocessing" }
});
Assert.IsTrue(response);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v1/fs/ids/file/c0c01799-df8b-4859-bcb1-0fb6a80fc9ac/properties/custom attributes",
requestMessage.RequestUri.ToString());
Assert.AreEqual(
"{\"reviewed\" : \"False\",\"contentType\" : \"application/vnd.openxmlformats-officedocument.wordprocessing\"}",
httpHandlerMock.GetRequestContentAsString());
}
public async Task UpdateFolder_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(UpdateFolderResponse)
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var response = await egnyteClient.Files.UpdateFolder(
"Shared/MyDocument",
folderDescription : "This is new description set up at: " + DateTime.Now,
publicLinks : PublicLinksType.Files,
restrictMoveDelete : true,
emailPreferences : "{\"content_updates\": false, \"content_accessed\":true}",
allowLinks : false);
Assert.AreEqual("/Shared/MyDocument", response.Path);
Assert.AreEqual("ApiTests2", response.Name);
Assert.AreEqual(new DateTime(2016, 1, 6, 20, 3, 30, DateTimeKind.Utc).ToLocalTime(), response.LastModified);
Assert.AreEqual("b0330bd2-4290-47bc-a537-e5520dc7d320", response.FolderId);
Assert.AreEqual("This is new description set up at: 2018-07-27 05:29:15", response.FolderDescription);
Assert.True(response.IsFolder);
Assert.AreEqual(PublicLinksType.Files, response.PublicLinks);
Assert.True(response.RestrictMoveDelete);
Assert.False(response.AllowLinks);
}
public async Task UpdateFileOrFolderCustomMetadata_ForFolder_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(UpdateFolderCustomMetadataResponse)
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var response = await egnyteClient.Files.UpdateFileOrFolderCustomMetadata(
"path",
"custom attributes",
new FileOrFolderCustomMetadataProperties
{
{ "reviewed", false },
{ "tags", "important" }
});
Assert.IsTrue(response);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v1/fs/ids/folder/b0330bd2-4290-47bc-a537-e5520dc7d320/properties/custom attributes",
requestMessage.RequestUri.ToString());
Assert.AreEqual(
"{\"reviewed\" : \"False\",\"tags\" : \"important\"}",
httpHandlerMock.GetRequestContentAsString());
}
public async Task SetFolderPermissions_HashCharactersInNameReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(string.Empty)
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var userList = await egnyteClient.Permissions.SetFolderPermissionsV2(
"Shared/myFolder with ##/",
new List <GroupOrUserPermissions> {
new GroupOrUserPermissions("jsmith", PermissionType.Viewer), new GroupOrUserPermissions("ajones", PermissionType.Viewer)
});
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v2/perms/Shared/myFolder with %23%23/",
requestMessage.RequestUri.ToString());
Assert.AreEqual(HttpMethod.Post, requestMessage.Method);
var content = httpHandlerMock.GetRequestContentAsString();
Assert.AreEqual(
TestsHelper.RemoveWhitespaces(SetFolderPermissionsRequestContent),
TestsHelper.RemoveWhitespaces(content));
}
public async Task SetFolderPermissions_WithInheritsPermissionsTrueAndKeepParentPermissions_ThrowsArgumentException()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(string.Empty)
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var exception = await AssertExtensions.ThrowsAsync <ArgumentException>(
() => egnyteClient.Permissions.SetFolderPermissionsV2(
"myPath",
inheritsPermissions: true,
keepParentPermissions: true));
Assert.IsTrue(exception.Message.Contains("inheritsPermissions"));
Assert.IsTrue(exception.Message.Contains("keepParentPermissions"));
Assert.IsNull(exception.InnerException);
}
public async Task DownloadFile_WithEntryId_ReturnsCorrectFile()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) => Task.FromResult(this.GetResponseMessage());
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var result = await egnyteClient.Files.DownloadFile("myFile", entryId : ETag).ConfigureAwait(false);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual("https://acme.egnyte.com/pubapi/v1/fs-content/myFile?entry_id=9c4c2443-5dbc-4afa-8d04-5620a778093c", requestMessage.RequestUri.ToString());
Assert.AreEqual(3, result.Data.Length);
Assert.AreEqual(0x20, result.Data[0]);
Assert.AreEqual(0x21, result.Data[1]);
Assert.AreEqual(0x22, result.Data[2]);
Assert.AreEqual(Checksum, result.Checksum);
Assert.AreEqual(new DateTimeOffset(2012, 08, 26, 5, 55, 29, TimeSpan.Zero).ToLocalTime().DateTime, result.LastModified);
Assert.AreEqual("\"" + ETag + "\"", result.ETag);
Assert.AreEqual(ContentType, result.ContentType);
Assert.AreEqual(ContentLength, result.ContentLength);
Assert.AreEqual(999, result.FullFileLength);
}
private async Task <UploadedFileMetadata> ChunkUploadFile(
EgnyteClient client,
string serverFilePath,
MemoryStream fileStream)
{
// first chunk
var defaultChunkLength = 10485760;
var firstChunkLength = defaultChunkLength;
if (fileStream.Length < firstChunkLength)
{
firstChunkLength = (int)fileStream.Length;
}
var bytesRead = firstChunkLength;
var buffer = new byte[firstChunkLength];
fileStream.Read(buffer, 0, firstChunkLength);
var response = await client.Files.ChunkedUploadFirstChunk(serverFilePath, new MemoryStream(buffer))
.ConfigureAwait(false);
int number = 2;
while (bytesRead < fileStream.Length)
{
var nextChunkLength = defaultChunkLength;
bool isLastChunk = false;
if (bytesRead + nextChunkLength >= fileStream.Length)
{
nextChunkLength = (int)fileStream.Length - bytesRead;
isLastChunk = true;
}
buffer = new byte[nextChunkLength];
fileStream.Read(buffer, 0, nextChunkLength);
if (!isLastChunk)
{
await client.Files.ChunkedUploadNextChunk(
serverFilePath,
number,
response.UploadId,
new MemoryStream(buffer)).ConfigureAwait(false);
}
else
{
return(await client.Files.ChunkedUploadLastChunk(
serverFilePath,
number,
response.UploadId,
new MemoryStream(buffer)).ConfigureAwait(false));
}
number++;
bytesRead += nextChunkLength;
}
throw new Exception("Something went wrong - unable to enumerate to next chunk.");
}
public async Task PartialGroupUpdate_WithMembersDelete_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
PartialGroupUpdateWithMembersDeleteResponseContent,
Encoding.UTF8,
"application/json")
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var groupDetails = await egnyteClient.Groups.PartialGroupUpdate(
"e3ba9d90-ebc7-483e-abaa-a84e92480c86",
members : new List <GroupMember>
{
new GroupMember(9967960066, true),
new GroupMember(9967960068, true)
});
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v2/groups/e3ba9d90-ebc7-483e-abaa-a84e92480c86",
requestMessage.RequestUri.ToString());
Assert.AreEqual(new HttpMethod("PATCH"), requestMessage.Method);
var content = httpHandlerMock.GetRequestContentAsString();
Assert.AreEqual(
TestsHelper.RemoveWhitespaces(PartialGroupUpdateWithMembersDeleteRequestContent),
TestsHelper.RemoveWhitespaces(content));
Assert.AreEqual(1, groupDetails.Schemas.Count);
Assert.AreEqual("urn:scim:schemas:core:1.0", groupDetails.Schemas[0]);
Assert.AreEqual("e3ba9d90-ebc7-483e-abaa-a84e92480c86", groupDetails.Id);
Assert.AreEqual("Finance", groupDetails.DisplayName);
Assert.AreEqual(2, groupDetails.Members.Count);
var firstMember = groupDetails.Members.FirstOrDefault(
u => u.Value == 9967960069);
Assert.IsNotNull(firstMember);
Assert.AreEqual("test", firstMember.Username);
Assert.AreEqual("Test User", firstMember.Display);
var secondMember = groupDetails.Members.FirstOrDefault(
u => u.Value == 9967960070);
Assert.IsNotNull(secondMember);
Assert.AreEqual("jdoe", secondMember.Username);
Assert.AreEqual("John Doe", secondMember.Display);
}
public async Task CreateLinkWithPassword_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.Created,
Content = new StringContent(
CreateLinkWithPasswordResponse,
Encoding.UTF8,
"application/json")
});
var newLink = GetNewLinkWithPassword();
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var existingLink = await egnyteClient.Links.CreateLink(newLink);
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual("https://acme.egnyte.com/pubapi/v1/links", requestMessage.RequestUri.ToString());
Assert.AreEqual(newLink.Path, existingLink.Path);
Assert.AreEqual(newLink.Type, existingLink.Type);
Assert.AreEqual(newLink.Accessibility, existingLink.Accessibility);
Assert.AreEqual(newLink.Password, existingLink.Password);
Assert.AreEqual(newLink.ExpiryDate, existingLink.ExpiryDate);
Assert.AreEqual(newLink.LinkToCurrent, existingLink.LinkToCurrent);
Assert.AreEqual(newLink.Notify, existingLink.Notify);
Assert.AreEqual(new DateTime(2012, 05, 02), existingLink.CreationDate);
Assert.AreEqual(newLink.SendEmail, existingLink.SendMail);
Assert.AreEqual(newLink.CopyMe, existingLink.CopyMe);
Assert.AreEqual(2, existingLink.Links.Count);
var firstLink = existingLink.Links.FirstOrDefault(l => l.Id == "47b774f66f344a67");
Assert.AreEqual(
"https://domain.egnyte.com/h-s/20130717/47b774f66f344a67",
firstLink.Url);
Assert.AreEqual(1, firstLink.Recipients.Count);
Assert.AreEqual("*****@*****.**", firstLink.Recipients[0]);
var secondLink = existingLink.Links.FirstOrDefault(l => l.Id == "47b774f66f344a68");
Assert.AreEqual(
"https://domain.egnyte.com/h-s/20130717/47b774f66f344a68",
secondLink.Url);
Assert.AreEqual(1, secondLink.Recipients.Count);
Assert.AreEqual("*****@*****.**", secondLink.Recipients[0]);
var content = httpHandlerMock.GetRequestContentAsString();
Assert.AreEqual(
TestsHelper.RemoveWhitespaces(CreateLinkWithPasswordRequestContent),
TestsHelper.RemoveWhitespaces(content));
}
public async Task UploadBigFile()
{
var client = new EgnyteClient(Token, Domain);
var fileStream = new MemoryStream(File.ReadAllBytes("c:/test/big-file.zip"));
var response = await ChunkUploadFile(client, "Shared/MikTests/Blog/big-file.zip", fileStream);
Assert.Pass();
}
public async Task CreateGroup_ReturnsSuccess()
{
var httpHandlerMock = new HttpMessageHandlerMock();
var httpClient = new HttpClient(httpHandlerMock);
httpHandlerMock.SendAsyncFunc =
(request, cancellationToken) =>
Task.FromResult(
new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
CreateGroupResponseContent,
Encoding.UTF8,
"application/json")
});
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var userList = await egnyteClient.Groups.CreateGroup("Finance",
new List <long> {
9967960066, 9967960068
});
var requestMessage = httpHandlerMock.GetHttpRequestMessage();
Assert.AreEqual(
"https://acme.egnyte.com/pubapi/v2/groups",
requestMessage.RequestUri.ToString());
Assert.AreEqual(HttpMethod.Post, requestMessage.Method);
var content = httpHandlerMock.GetRequestContentAsString();
Assert.AreEqual(
TestsHelper.RemoveWhitespaces(CreateGroupRequestContent),
TestsHelper.RemoveWhitespaces(content));
Assert.AreEqual(1, userList.Schemas.Count);
Assert.AreEqual("urn:scim:schemas:core:1.0", userList.Schemas[0]);
Assert.AreEqual("e3ba9d90-ebc7-483e-abaa-a84e92480c86", userList.Id);
Assert.AreEqual("Finance", userList.DisplayName);
Assert.AreEqual(2, userList.Members.Count);
var firstMember = userList.Members.FirstOrDefault(
u => u.Value == 9967960066);
Assert.IsNotNull(firstMember);
Assert.AreEqual("test", firstMember.Username);
Assert.AreEqual("Test User", firstMember.Display);
var secondMember = userList.Members.FirstOrDefault(
u => u.Value == 9967960068);
Assert.IsNotNull(secondMember);
Assert.AreEqual("jdoe", secondMember.Username);
Assert.AreEqual("John Doe", secondMember.Display);
}
public async Task CreateGroup_WhenDisplayNameEmpty_ThrowsException()
{
var httpClient = new HttpClient(new HttpMessageHandlerMock());
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var exception = await AssertExtensions.ThrowsAsync <ArgumentNullException>(
() => egnyteClient.Groups.CreateGroup(string.Empty, new List <long>()));
Assert.IsTrue(exception.Message.Contains("displayName"));
Assert.IsNull(exception.InnerException);
}
public async Task CreateGroup_WhenMembersAreNull_ThrowsException()
{
var httpClient = new HttpClient(new HttpMessageHandlerMock());
var egnyteClient = new EgnyteClient("token", "acme", httpClient);
var exception = await AssertExtensions.ThrowsAsync <ArgumentNullException>(
() => egnyteClient.Groups.CreateGroup("name", null));
Assert.IsTrue(exception.Message.Contains("members"));
Assert.IsNull(exception.InnerException);
}
