public async Task GetWorkItemAsync_ReturnsWorkItem()
{
// Arrange
WorkItemSummary summary = new WorkItemSummary
{
Id = 1
};
httpClientMock.WorkItemDetail = new WorkItemDetails
{
FileAttachments = new List <WorkItemFileAttachment>(),
Comments = new List <WorkItemComment>(),
WorkItem = new WorkItem()
{
Id = summary.Id
},
CanDeleteComments = true,
CanDeleteWorkItem = true
};
httpClientMock.SetupMock();
// Act
WorkItemDetails details = await codePlexReader.GetWorkItemAsync(summary);
// Assert
// Spot check. Really the method should just be returning the serialized object from the endpoint
// so doing a deep check on the item would be a lot of verification of Newtonsoft.Json
Assert.True(details.WorkItem.Id == summary.Id);
}
public async Task CreateWorkItemAsync_OnWorkItemWithFeatureIssueAndTextTypes_SetsIssueTypeLabel(string codePlexWorkItemType, string gitHubLabel)
{
// Arrange
var issuesMock = new GitHubIssueMock();
var ctorArgs = new CtorArgs {
Issues = issuesMock.Issues
};
GitHubRepoIssueReaderWriter target = CreateTarget(ctorArgs);
WorkItemDetails workItemDetails = CreateSampleWorkItemDetails(type: codePlexWorkItemType);
// Act
await target.WriteWorkItemAsync(workItemDetails);
// Assert
if (gitHubLabel != null)
{
Assert.Equal(2, issuesMock.UpdateIssueArgs.IssueUpdate.Labels.Count);
Assert.Contains(gitHubLabel, issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
}
else
{
Assert.Single(issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
}
Assert.Contains(GitHubLabels.CodePlexMigrated, issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
}
private void ClearListView()
{
if (WorkItemDetails != null)
{
WorkItemDetails.Clear();
}
}
public async Task CreateWorkItemAsync_OnDuplicateWorkItem_SetsDuplicateLabel(bool isIssueDuplicate)
{
// Arrange
var issuesMock = new GitHubIssueMock();
var ctorArgs = new CtorArgs {
Issues = issuesMock.Issues
};
GitHubRepoIssueReaderWriter target = CreateTarget(ctorArgs);
WorkItemDetails workItemDetails = CreateSampleWorkItemDetails(isDuplicate: isIssueDuplicate);
// Act
await target.WriteWorkItemAsync(workItemDetails);
// Assert
if (isIssueDuplicate)
{
Assert.Equal(2, issuesMock.UpdateIssueArgs.IssueUpdate.Labels.Count);
Assert.Contains(GitHubLabels.Duplicate, issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
}
else
{
Assert.Single(issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
}
Assert.Contains(GitHubLabels.CodePlexMigrated, issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
}
private async Task CheckForWorkItemFailureAsync(string workItemName, string jobName)
{
await Task.Yield();
try
{
WorkItemDetails details = await HelixApi.RetryAsync(
() => HelixApi.WorkItem.DetailsAsync(workItemName, jobName),
LogExceptionRetry);
string message = $"Work item {workItemName} in job {jobName} has {details.State} with exit code {details.ExitCode}";
if (IsFailed(details))
{
Log.LogError(message);
}
else
{
Log.LogMessage(MessageImportance.Low, message);
}
}
catch (Exception ex)
{
Log.LogError($"Unable to get work item status for '{workItemName}', assuming failure. Exception: {ex}");
}
}
public static void InsertOneStudyTable(WorkItem item, WorkItemDetails itemDetails)
{
using (IDbConnection connection = CreateConnection())
{
connection.Open();
using (IDbCommand cmd = connection.CreateCommand())
{
cmd.CommandText = @"
INSERT INTO OnlyOneStudy(PatientId, PatientKanjiName, PatientKanaName, PatientBirthDate, PatientGender, OrderNumber, StudyStatus, ScheduledOn, StudyTypeName, Comment, ShotItemName)
VALUES(@PatientId, @PatientKanjiName, @PatientKanaName, @PatientBirthDate, @PatientGender, @OrderNumber, @StudyStatus, @ScheduledOn, @StudyTypeName, @Comment, @ShotItemName);";
AddQueryParam(cmd, "PatientId", item.PatientId);
AddQueryParam(cmd, "PatientKanjiName", item.PatientKanjiName);
AddQueryParam(cmd, "PatientKanaName", item.PatientKanaName);
AddQueryParam(cmd, "PatientBirthDate", itemDetails.PatientBirthDate);
AddQueryParam(cmd, "PatientGender", itemDetails.PatientGender);
AddQueryParam(cmd, "OrderNumber", item.OrderNumber);
AddQueryParam(cmd, "StudyStatus", item.StudyStatus);
AddQueryParam(cmd, "ScheduledOn", item.ScheduledOn);
AddQueryParam(cmd, "StudyTypeName", item.StudyTypeName);
AddQueryParam(cmd, "Comment", item.Comment);
AddQueryParam(cmd, "ShotItemName", item.ShotItemName);
cmd.ExecuteNonQuery();
}
}
}
public StudyDetails(WorkItem item, WorkItemDetails itemDetails)
{
InitializeComponent();
this._item = item;
this._itemDetails = itemDetails;
}
public void BuildWorkItemLists(int numberOfWorkItems)
{
Summaries = new List <WorkItemSummary>();
WorkItems = new List <WorkItemDetails>();
for (int i = 0; i < numberOfWorkItems; i++)
{
WorkItemSummary newSummary = new WorkItemSummary
{
Id = i
};
Summaries.Add(newSummary);
WorkItemDetails newDetails = new WorkItemDetails
{
WorkItem = new WorkItem
{
Id = i
}
};
WorkItems.Add(newDetails);
}
SetupMock();
}
/// <summary>
/// 詳細表示
/// </summary>
/// <param name="patientId"></param>
/// <returns></returns>
public static WorkItemDetails SearchItemDetails(string patientId)
{
WorkItemDetails itemDetails = null;
using (IDbConnection connection = CreateConnection())
{
connection.Open();
using (IDbCommand cmd = connection.CreateCommand())
{
cmd.CommandText = @"
SELECT SO.StudiedAt, P.PatientBirthDate, P.PatientGender
FROM dbo.StudyOrders AS SO INNER JOIN
dbo.Patients AS P
ON SO.PatientId = P.PatientId
WHERE SO.PatientId = @PatientId;";
AddQueryParam(cmd, "PatientId", patientId);
IDataReader reader = cmd.ExecuteReader();
if (reader.Read())
{
itemDetails = new WorkItemDetails();
itemDetails.StudiedAt = (DateTime)reader["StudiedAt"];
itemDetails.PatientBirthDate = (DateTime)reader["PatientBirthDate"];
itemDetails.PatientGender = (string)reader["PatientGender"];
}
return(itemDetails);
}
}
}
private async Task OnSaveClicked(object arg)
{
ErrorHeader = "Error(s) occurred during save";
Errors = string.Empty;//clear previous error messages
var workItemDetail = WorkItemDetails.FirstOrDefault(x => x.IsChecked);
if (workItemDetail != null)
{
IsLoading = Visibility.Visible;
var workItem = workItemDetail.WorkItemCache;
await Task.Run(() =>
{
int[] changesetIds =
VersionControlExt.History.ActiveWindow.SelectedChangesets.Select(x => x.ChangesetId).ToArray();
foreach (int changesetId in changesetIds)
{
Changeset changeset = VersionControlServer.GetChangeset(changesetId);
try
{
workItem.Links.Add(new ExternalLink(
WorkItemStore.RegisteredLinkTypes[ArtifactLinkIds.Changeset],
changeset.ArtifactUri.AbsoluteUri));
var validationErrors = workItem.Validate();
if (validationErrors.Count == 0)
{
workItem.Save();
}
else
{
foreach (var validationError in validationErrors)
{
Errors += string.Format("{0}{1}", validationError, Environment.NewLine);
}
HasErrors = Visibility.Visible;
IsLoading = Visibility.Collapsed;
}
}
catch (Exception exception)
{
//TODO:Logging
//To catch duplicate links
HasErrors = Visibility.Visible;
IsLoading = Visibility.Collapsed;
Errors += string.Format("{0}{1}", exception.Message, Environment.NewLine);
}
}
});
if (HasErrors == Visibility.Collapsed)
{
//no errors
CloseWindow();
}
IsLoading = Visibility.Collapsed;
}
}
/// <summary>
/// 検査詳細ボタンを押下
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void StudyDetailsButtonClick(object sender, EventArgs e)
{
if (studyListDataGridView.SelectedRows.Count != 0)
{
WorkItem item = studyListDataGridView.CurrentRow.DataBoundItem as WorkItem;
WorkItemDetails itemDetails = DbManager.SearchItemDetails(item.PatientId);
StudyDetails studydetail = new StudyDetails(item, itemDetails);
studydetail.ShowDialog();
}
}
public async Task UpdateWorkItemAsync_IfWorkItemExists_Succeeds(bool hasAttachments)
{
// Arrange
Issue issue = CreateSampleIssue(label: "AnyLabel");
WorkItemDetails workItemDetails = CreateSampleWorkItemDetails(hasAttachments: hasAttachments);
var issuesMock = new GitHubIssueMock();
var searchMock = new GitHubSearchInBodyMock(searchResults: new[] { issue });
CtorArgs ctorArgs = new CtorArgs {
Search = searchMock.Search, Issues = issuesMock.Issues
};
GitHubRepoIssueReaderWriter target = CreateTarget(ctorArgs);
// Act
await target.UpdateWorkItemAsync(workItemDetails);
// Assert: Search
Assert.Contains(workItemDetails.WorkItem.Id.ToString(), searchMock.SearchIssuesRequest.Term);
Assert.Equal(IssueTypeQualifier.Issue, searchMock.SearchIssuesRequest.Type);
Assert.Single(searchMock.SearchIssuesRequest.Repos);
Assert.Equal(ctorArgs.FullRepoName, searchMock.SearchIssuesRequest.Repos[0]);
Assert.Contains(searchMock.SearchIssuesRequest.In, q => q == IssueInQualifier.Body);
searchMock.VerifySearchCallCount(callCount: 1);
// Assert: Update -- Owner + Repo + Issue number
Assert.Equal(ctorArgs.RepoOwner, issuesMock.UpdateIssueArgs.Owner);
Assert.Equal(ctorArgs.Repo, issuesMock.UpdateIssueArgs.Name);
Assert.Equal(issue.Number, issuesMock.UpdateIssueArgs.Number);
// Assert: Update -- Title + Body
Assert.Equal(workItemDetails.WorkItem.Summary, issuesMock.UpdateIssueArgs.IssueUpdate.Title);
Assert.Contains(TextUtilities.GetFormattedWorkItemBody(workItemDetails.WorkItem, workItemDetails.FileAttachments), issuesMock.UpdateIssueArgs.IssueUpdate.Body);
// Assert: Update -- Labels
Assert.Single(issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
Assert.Contains(issuesMock.UpdateIssueArgs.IssueUpdate.Labels, label => label == GitHubLabels.CodePlexMigrated);
// Assert: Update -- Attachments
if (hasAttachments)
{
Assert.Contains(Resources.Attachments, issuesMock.UpdateIssueArgs.IssueUpdate.Body);
}
else
{
Assert.DoesNotContain(Resources.Attachments, issuesMock.UpdateIssueArgs.IssueUpdate.Body);
}
issuesMock.VerifyIssuesCallCount(methodName: nameof(IIssuesClient.Update), callCount: 2);
}
public async Task CreateWorkItemAsync_OnNonNullWorkItemDetailsAndWorkItem_CreatesIssue(bool isIssueClosed, bool hasAttachments)
{
// Arrange
var issuesMock = new GitHubIssueMock();
var ctorArgs = new CtorArgs {
Issues = issuesMock.Issues
};
GitHubRepoIssueReaderWriter target = CreateTarget(ctorArgs);
WorkItemDetails workItemDetails = CreateSampleWorkItemDetails(hasAttachments: hasAttachments, isClosed: isIssueClosed);
// Act
await target.WriteWorkItemAsync(workItemDetails);
// Assert: Owner + Repo
Assert.NotNull(issuesMock.CreateIssueArgs.NewIssue);
Assert.Equal(ctorArgs.RepoOwner, issuesMock.CreateIssueArgs.Owner);
Assert.Equal(ctorArgs.Repo, issuesMock.CreateIssueArgs.Name);
// Assert: Title + Body
Assert.Equal(workItemDetails.WorkItem.Summary, issuesMock.CreateIssueArgs.NewIssue.Title);
Assert.Contains(TextUtilities.GetFormattedWorkItemBody(workItemDetails.WorkItem, workItemDetails.FileAttachments), issuesMock.CreateIssueArgs.NewIssue.Body);
// Assert: Labels
Assert.Single(issuesMock.CreateIssueArgs.NewIssue.Labels);
Assert.Contains(issuesMock.CreateIssueArgs.NewIssue.Labels, label => label == GitHubLabels.CodePlexMigrationInitiated);
Assert.Single(issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
Assert.Contains(issuesMock.UpdateIssueArgs.IssueUpdate.Labels, label => label == GitHubLabels.CodePlexMigrated);
// Assert: Attachments
if (hasAttachments)
{
Assert.Contains(Resources.Attachments, issuesMock.CreateIssueArgs.NewIssue.Body);
}
else
{
Assert.DoesNotContain(Resources.Attachments, issuesMock.CreateIssueArgs.NewIssue.Body);
}
// Assert: Issue state: closed/open
Assert.Equal(isIssueClosed ? ItemState.Closed : (ItemState?)null, issuesMock.UpdateIssueArgs.IssueUpdate.State);
issuesMock.VerifyIssuesCallCount(methodName: nameof(IIssuesClient.Create), callCount: 1);
issuesMock.VerifyIssuesCallCount(methodName: nameof(IIssuesClient.Update), callCount: 1);
issuesMock.VerifyCommentCallCount(methodName: nameof(IIssueCommentsClient.Create), callCount: 0);
issuesMock.VerifyCommentCallCount(methodName: nameof(IIssueCommentsClient.Delete), callCount: 0);
}
public async Task UpdateWorkItemAsync_IfWorkItemHasComments_DropsAndRecreatesComments()
{
// Arrange
int issueCommentCount = 10;
Issue issue = CreateSampleIssue(label: "AnyLabel");
IssueComment[] issueComments = Enumerable.Range(0, issueCommentCount).Select(i => CreateSampleComment(issue.Number)).ToArray();
WorkItemDetails workItemDetails = CreateSampleWorkItemDetails(hasComments: true);
var issuesMock = new GitHubIssueMock();
issuesMock.SetCommentsForIssue(issue.Number, issueComments);
var searchMock = new GitHubSearchInBodyMock(searchResults: new[] { issue });
CtorArgs ctorArgs = new CtorArgs {
Search = searchMock.Search, Issues = issuesMock.Issues
};
GitHubRepoIssueReaderWriter target = CreateTarget(ctorArgs);
// Act
await target.UpdateWorkItemAsync(workItemDetails);
// Assert: Search
searchMock.VerifySearchCallCount(callCount: 1);
// Assert: Delete comments
Assert.True(issuesMock.DeleteCommentArgs.All(args => args.Owner == ctorArgs.RepoOwner));
Assert.True(issuesMock.DeleteCommentArgs.All(args => args.Name == ctorArgs.Repo));
Assert.Equal(issueComments.Select(c => c.Id), issuesMock.DeleteCommentArgs.Select(args => args.Id));
issuesMock.VerifyCommentCallCount(nameof(IIssueCommentsClient.Delete), callCount: issueCommentCount);
// Assert: Create comments
Assert.True(issuesMock.CreateCommentArgs.All(args => args.Owner == ctorArgs.RepoOwner));
Assert.True(issuesMock.CreateCommentArgs.All(args => args.Name == ctorArgs.Repo));
Assert.True(issuesMock.CreateCommentArgs.All(args => args.Number == issue.Number));
string[] createdComments = issuesMock.CreateCommentArgs.Select(c => c.NewComment).ToArray();
foreach (WorkItemComment comment in workItemDetails.Comments)
{
Assert.Contains(createdComments, c => c.Contains(comment.Message));
}
issuesMock.VerifyCommentCallCount(nameof(IIssueCommentsClient.Create), callCount: workItemDetails.Comments.Count());
}
public async Task CreateWorkItemAsync_OnWorkItemWithReleaseComponentAndPriority_SetsTextLabels()
{
// Arrange
var issuesMock = new GitHubIssueMock();
var ctorArgs = new CtorArgs {
Issues = issuesMock.Issues
};
GitHubRepoIssueReaderWriter target = CreateTarget(ctorArgs);
WorkItemDetails workItemDetails = CreateSampleWorkItemDetails(hasSpecialProperties: true);
// Act
await target.WriteWorkItemAsync(workItemDetails);
// Assert
Assert.Equal(4, issuesMock.UpdateIssueArgs.IssueUpdate.Labels.Count);
Assert.Contains(workItemDetails.WorkItem.PlannedForRelease, issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
Assert.Contains(workItemDetails.WorkItem.AffectedComponent.DisplayName, issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
Assert.Contains(issuesMock.UpdateIssueArgs.IssueUpdate.Labels, label => label.Contains(GitHubLabels.Impact) && label.Contains(workItemDetails.WorkItem.Priority.Name));
Assert.Contains(GitHubLabels.CodePlexMigrated, issuesMock.UpdateIssueArgs.IssueUpdate.Labels);
}
public static async void GetWorkItem(string username, string password, int id)
{
try
{
var personalAccessToken = "yggseimvsboxrc3rvodr4dzshnc6cch6shcyavjrqxxbydb6geda";
Console.ReadKey();
//var personalAccessToken = String.Empty;
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
//provide the personal access token through an HTTP header, convert it to a Base64 string
//The resulting string can then be provided as an HTTP header in the format:
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(
Encoding.ASCII.GetBytes(
string.Format("{0}:{1}:{2}", username, personalAccessToken, id))));
//var param = "abc123";
//var url = $"https://ndi-tfs.visualstudio.com/Web%20Hook/_apis/wit/workitems?ids={id}&api-version=5.1";
//process the response stream
string url = $"https://ndi-tfs.visualstudio.com/Web%20Hook/_apis/wit/workitems/$Product%20Backlog%20Item?api-version=5.1";
using (HttpResponseMessage response = client.GetAsync(url).Result)
{
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
WorkItemDetails wiDetails = JsonConvert.DeserializeObject <WorkItemDetails>(responseBody);
Console.WriteLine("Work Item ID: \t" + wiDetails.id);
foreach (KeyValuePair <string, string> fld in wiDetails.fields)
{
Console.WriteLine(fld.Key + ":\t" + fld.Value);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.WriteLine(ex);
}
}
public async Task CreateWorkItemAsync_OnWorkItemWithComments_CreatesCommentsOnIssue()
{
// Arrange
var issuesMock = new GitHubIssueMock();
var ctorArgs = new CtorArgs {
Issues = issuesMock.Issues
};
GitHubRepoIssueReaderWriter target = CreateTarget(ctorArgs);
WorkItemDetails workItemDetails = CreateSampleWorkItemDetails(hasComments: true);
// Act
await target.WriteWorkItemAsync(workItemDetails);
// Assert
Assert.True(issuesMock.CreateCommentArgs.All(argSet => argSet.Name == ctorArgs.Repo && argSet.Owner == ctorArgs.RepoOwner));
issuesMock.VerifyCommentCallCount(methodName: nameof(IIssueCommentsClient.Create), callCount: workItemDetails.Comments.Count());
foreach (WorkItemComment comment in workItemDetails.Comments)
{
Assert.Contains(issuesMock.CreateCommentArgs, argSet => argSet.NewComment.Contains(comment.Message));
}
}
private void OnOpenWorkItemClicked(object arg)
{
var workItemDetail = WorkItemDetails.FirstOrDefault(x => x.IsChecked);
var workItemDocumentService = DocumentService;
if (workItemDetail != null && workItemDocumentService != null)
{
IsLoading = Visibility.Visible;
var workItemDocument = workItemDocumentService.GetWorkItem(TeamFoundationContext.TeamProjectCollection, workItemDetail.Id, this);
try
{
if (!workItemDocument.IsLoaded)
{
workItemDocument.Load();
}
workItemDocumentService.ShowWorkItem(workItemDocument);
}
catch (Exception exception)
{
//TODO: Logging
}
finally
{
workItemDocument.Release(this);
}
IsLoading = Visibility.Collapsed;
}
else
{
HasErrors = Visibility.Visible;
IsLoading = Visibility.Collapsed;
ErrorHeader = "Error(s)";
Errors = "Error occurred while opening the work item.";
}
}
public void Init()
{
instance = new WorkItemDetails();
}
private bool IsFailed(WorkItemDetails details)
{
// The State property will not be populated with "Failed" if kusto hasn't finished ingesting data. Check the ExitCode also.
return(details.State == "Failed" || details.ExitCode != 0);
}
private bool CanExecuteSave(object o)
{
var canExecuteSave = WorkItemDetails != null && WorkItemDetails.Any(x => x.IsChecked);
return(canExecuteSave);
}
private static WorkItemDetails CreateSampleWorkItemDetails(
string type = null,
bool isClosed = false,
bool isDuplicate = false,
bool hasSpecialProperties = false,
bool hasComments = false,
bool hasAttachments = false)
{
int r = RandomGenerator.Next(Int32.MaxValue);
var result = new WorkItemDetails
{
WorkItem = new WorkItem
{
Id = r,
Summary = "WorkItemSummary-" + r,
PlainDescription = "PlainDescription-" + r,
}
};
if (type != null)
{
result.WorkItem.Type = new WorkItemType {
Id = r, Name = type
};
}
if (isClosed)
{
result.WorkItem.Status = new WorkItemStatus {
Id = r, Name = CodePlexStrings.Closed
};
}
if (isDuplicate)
{
result.WorkItem.ReasonClosed = new WorkItemReasonClosed {
Name = isDuplicate ? CodePlexStrings.Duplicate : "Reason"
};
}
if (hasSpecialProperties)
{
result.WorkItem.PlannedForRelease = "RTM";
result.WorkItem.AffectedComponent = new WorkItemComponent {
DisplayName = "ComponentDisplayName-" + r, Name = "ComponentName-" + r
};
result.WorkItem.Priority = new WorkItemPriority {
Id = 0, Name = "PriorityName-" + r, Severity = 0
};
}
if (hasComments)
{
result.Comments = new[]
{
new WorkItemComment
{
Id = r,
Message = "CommentMessage-" + r,
PostedBy = "AuthorName-" + r,
PostedDate = DateTimeOffset.UtcNow,
WorkItemId = result.WorkItem.Id,
},
};
}
if (hasAttachments)
{
result.FileAttachments = new[]
{
new WorkItemFileAttachment
{
FileId = r,
FileName = "FileName-" + r,
DownloadUrl = new Uri("http://file-url-" + r),
WorkItemId = result.WorkItem.Id,
},
};
}
return(result);
}
