public async Task ExecuteExceptionIsInstrumentedTest()
{
// given
var handler = new MockVstsHandler()
{
MockExecuteFunc = (msg) => { throw new NotSupportedException(); }
};
var traceBrokerInstrumentation = new TraceBrokerInstrumentation();
var testVstsMessage = new TestVstsMessage()
{
RequestType = RequestType.Execute
};
// when
var instrumentedHandler = new HandlerWithInstrumentation <TestVstsMessage>(traceBrokerInstrumentation, handler);
Exception actualEx = null;
try
{
await instrumentedHandler.Execute(testVstsMessage, default(CancellationToken));
}
catch (NotSupportedException ex)
{
actualEx = ex;
}
// then
Assert.IsNotNull(actualEx);
Assert.AreEqual(1, traceBrokerInstrumentation.Events.Count(x => x.Equals(testVstsMessage.RequestType.ToString())));
Assert.AreEqual(1, traceBrokerInstrumentation.Events.Count(x => x.Equals(HandlerWithInstrumentation <TestVstsMessage> .HandlerExecuteFailedEventName)));
Assert.AreEqual(1, traceBrokerInstrumentation.Events.Count(x => x.Equals("NotSupportedException")));
}
public async Task MultipleEventsInstrumentedTest()
{
// given
var handler = new MockVstsHandler()
{
MockExecuteFunc = (msg) => Task.FromResult(new VstsScheduleResult())
};
var traceBrokerInstrumentation = new TraceBrokerInstrumentation();
var testVstsMessage = new TestVstsMessage()
{
RequestType = RequestType.Execute
};
var events = new List <string>();
// when
events.Add(string.Format("[{0}] INFO: {1}: {2}", DateTime.UtcNow.ToString("o"), testVstsMessage.RequestType.ToString(), "Processing request"));
var result = await handler.Execute(testVstsMessage, default(CancellationToken));
events.Add(string.Format("[{0}] INFO: {1}: {2}: {3}", DateTime.UtcNow.ToString("o"), testVstsMessage.RequestType.ToString(), "Processed request", result.Message));
var logStream = GenerateStreamFromStringList(events);
await traceBrokerInstrumentation.HandleEventList(logStream, eventProperties : null, cancellationToken : default(CancellationToken));
// then
var requestType = testVstsMessage.RequestType.ToString();
var logMessages = traceBrokerInstrumentation.Events.First(x => x.Contains(requestType));
Assert.IsNotNull(logMessages);
Assert.IsTrue(logMessages.IndexOf(requestType) >= 0);
Assert.IsTrue(logMessages.Contains("Processing request"));
Assert.IsTrue(logMessages.Contains("Processed request"));
}
internal static MockServiceBusMessage CreateMockMessage(TestVstsMessage testMessage)
{
var testMessageJson = JsonConvert.SerializeObject(testMessage);
var mockMessage = new MockServiceBusMessage {
BodyObject = testMessageJson
};
return(mockMessage);
}
internal static TestVstsMessage CreateValidTestVstsMessage()
{
var testVstsMessage = new TestVstsMessage()
{
VstsHub = HubType.Build, VstsUrl = "http://vstsUrl", VstsPlanUrl = "http://vstsPlanUrl", AuthToken = "someToken", ProjectId = Guid.NewGuid(), JobId = Guid.NewGuid(), PlanId = Guid.NewGuid(), BuildProperties = new VstsBuildProperties {
SourceControlServerUri = "haha"
}
};
return(testVstsMessage);
}
internal static TestVstsMessage CreateValidTestVstsMessageForRelease()
{
var testVstsMessage = new TestVstsMessage()
{
VstsHub = HubType.Release, VstsUrl = "http://vstsUrl", VstsPlanUrl = "http://vstsPlanUrl", AuthToken = "someToken", ProjectId = Guid.NewGuid(), JobId = Guid.NewGuid(), PlanId = Guid.NewGuid(), ReleaseProperties = new VstsReleaseProperties()
{
ReleaseId = 123, ReleaseDefinitionName = "someReleaseDef", ReleaseEnvironmentName = "env123", ReleaseEnvironmentUri = new Uri("foo://bar"), ReleaseName = "someRelease", ReleaseUri = new Uri("foo://bar")
}
};
return(testVstsMessage);
}
private static async Task TestReportJobStarted(ReleaseStatus releaseStatus, bool returnNullRelease, int expectedEventCount)
{
// given
VstsMessage vstsContext = new TestVstsMessage
{
VstsHub = HubType.Release,
VstsUri = new Uri("http://vstsUri"),
VstsPlanUri = new Uri("http://vstsPlanUri"),
ReleaseProperties = new VstsReleaseProperties(),
};
var mockBuildClient = new MockBuildClient()
{
MockBuild = new Build()
{
Status = BuildStatus.None
},
ReturnNullBuild = false,
};
var mockReleaseClient = new MockReleaseClient()
{
MockRelease = new Release()
{
Status = releaseStatus
},
ReturnNullRelease = returnNullRelease,
};
var mockTaskClient = new MockTaskClient();
var reportingHelper = new VstsReportingHelper(vstsContext, new TraceBrokerInstrumentation(), new Dictionary <string, string>())
{
CreateReleaseClient = (uri, s) => ReturnMockReleaseClientIfUrlValid(uri, vstsContext, mockReleaseClient),
CreateBuildClient = (uri, s) => mockBuildClient,
CreateTaskHttpClient = (uri, s, i, r) => mockTaskClient
};
// when
await reportingHelper.ReportJobStarted(DateTime.UtcNow, "test message", default(CancellationToken));
// then
Assert.AreEqual(expectedEventCount, mockTaskClient.EventsReceived.Count);
if (expectedEventCount != 0)
{
var taskEvent = mockTaskClient.EventsReceived[0] as JobStartedEvent;
Assert.IsNotNull(taskEvent);
}
}
private static async Task TestReportJobStarted(ReleaseStatus releaseStatus, bool returnNullRelease, int expectedEventCount)
{
// given
VstsMessage vstsContext = new TestVstsMessage
{
VstsHub = HubType.Release,
VstsUri = new Uri("http://vstsUri"),
VstsPlanUri = new Uri("http://vstsPlanUri"),
ReleaseProperties = new VstsReleaseProperties(),
};
var mockBuildClient = new MockBuildClient()
{
MockBuild = new Build()
{
Status = BuildStatus.None
},
ReturnNullBuild = false,
};
var mockReleaseClient = new MockReleaseClient()
{
MockRelease = new Release()
{
Status = releaseStatus
},
ReturnNullRelease = returnNullRelease,
};
var mockTaskClient = new MockTaskClient();
Assert.AreNotEqual(vstsContext.VstsUri, vstsContext.VstsPlanUri, "need to be different to ensure we can test correct one is used");
var reportingHelper = new TestableJobStatusReportingHelper(vstsContext, new TraceLogger(), mockTaskClient, mockReleaseClient, mockBuildClient);
// when
await reportingHelper.ReportJobStarted(DateTime.UtcNow, "test message", default(CancellationToken));
// then
Assert.AreEqual(expectedEventCount, mockTaskClient.EventsReceived.Count);
if (expectedEventCount != 0)
{
var taskEvent = mockTaskClient.EventsReceived[0] as JobStartedEvent;
Assert.IsNotNull(taskEvent);
}
}
public async Task ExecuteIsInstrumentedTest()
{
// given
var handler = new MockVstsHandler()
{
MockExecuteFunc = (msg) => Task.FromResult(new VstsScheduleResult())
};
var traceBrokerInstrumentation = new TraceBrokerInstrumentation();
var testVstsMessage = new TestVstsMessage()
{
RequestType = RequestType.Execute
};
// when
var instrumentedHandler = new HandlerWithInstrumentation <TestVstsMessage>(traceBrokerInstrumentation, handler);
await instrumentedHandler.Execute(testVstsMessage, default(CancellationToken));
// then
Assert.AreEqual(2, traceBrokerInstrumentation.Events.Count(x => x.Equals(testVstsMessage.RequestType.ToString())));
}
private static async Task TestReportJobStarted(BuildStatus buildStatus, bool returnNullBuild, int expectedEventCount)
{
// given
VstsMessage vstsContext = new TestVstsMessage
{
VstsHub = HubType.Build,
VstsUri = new Uri("http://vstsUri"),
VstsPlanUri = new Uri("http://vstsPlanUri"),
BuildProperties = new VstsBuildProperties(),
};
var mockBuildClient = new MockBuildClient()
{
MockBuild = new Build()
{
Status = buildStatus
},
ReturnNullBuild = returnNullBuild,
};
var mockTaskClient = new MockTaskClient();
var mockReleaseClient = new MockReleaseClient();
var reportingHelper = new TestableJobStatusReportingHelper(vstsContext, new TraceLogger(), mockTaskClient, mockReleaseClient, mockBuildClient)
{
//CreateBuildClient = (uri, s) => ReportingBrokerJobCompletedTests.ReturnMockBuildClientIfUrlValid(uri, vstsContext, mockBuildClient),
//CreateReleaseClient = (uri, t) => mockReleaseClient
};
// when
await reportingHelper.ReportJobStarted(DateTime.UtcNow, "test message", default(CancellationToken));
// then
Assert.AreEqual(expectedEventCount, mockTaskClient.EventsReceived.Count);
if (expectedEventCount != 0)
{
var taskEvent = mockTaskClient.EventsReceived[0] as JobStartedEvent;
Assert.IsNotNull(taskEvent);
}
}
private async Task TestReportJobCompleted(BuildStatus buildStatus, bool returnNullBuild, bool isPassed, int expectedEventCount, TaskResult expectedResult, int expectedRecordCount = 0, string timeLineRecordName = null)
{
// given
Guid parentId = Guid.NewGuid();
Guid childId = Guid.NewGuid();
VstsMessage vstsContext = new TestVstsMessage
{
JobId = parentId,
VstsHub = HubType.Build,
VstsUri = new Uri("http://vstsUri"),
VstsPlanUri = new Uri("http://vstsPlanUri"),
BuildProperties = new VstsBuildProperties(),
};
var mockBuildClient = new MockBuildClient()
{
MockBuild = new Build()
{
Status = buildStatus
},
ReturnNullBuild = returnNullBuild,
};
var mockReleaseClient = new MockReleaseClient()
{
MockRelease = new Release()
{
Status = ReleaseStatus.Undefined
},
ReturnNullRelease = false,
};
var timelineRecords = new List <Microsoft.TeamFoundation.DistributedTask.WebApi.TimelineRecord>
{
new Microsoft.TeamFoundation.DistributedTask.WebApi.TimelineRecord()
{
Id = parentId
},
new Microsoft.TeamFoundation.DistributedTask.WebApi.TimelineRecord()
{
Id = childId,
ParentId = parentId
},
new Microsoft.TeamFoundation.DistributedTask.WebApi.TimelineRecord()
{
// Should be ignored
Id = Guid.NewGuid()
}
};
if (!string.IsNullOrEmpty(timeLineRecordName))
{
timelineRecords.Add(new Microsoft.TeamFoundation.DistributedTask.WebApi.TimelineRecord()
{
Id = Guid.NewGuid(),
Name = timeLineRecordName
});
}
var mockTaskHttpClient = new MockTaskClient()
{
GetRecordsReturnCollection = timelineRecords
};
var reportingHelper = new VstsReportingHelper(vstsContext, new TraceBrokerInstrumentation(), new Dictionary <string, string>(), timeLineRecordName)
{
CreateBuildClient = (uri, s) => ReturnMockBuildClientIfUrlValid(uri, vstsContext, mockBuildClient),
CreateReleaseClient = (uri, s) => mockReleaseClient,
CreateTaskHttpClient = (uri, s, i, r) => mockTaskHttpClient
};
// when
await reportingHelper.ReportJobCompleted(DateTime.UtcNow, "test message", isPassed, default(CancellationToken));
// then
Assert.AreEqual(expectedEventCount, mockTaskHttpClient.EventsReceived.Count);
if (expectedEventCount != 0)
{
var taskEvent = mockTaskHttpClient.EventsReceived[0] as JobCompletedEvent;
Assert.IsNotNull(taskEvent);
Assert.AreEqual(taskEvent.Result, expectedResult);
}
Assert.AreEqual(expectedRecordCount, mockTaskHttpClient.TimelineRecordsUpdated.Count);
if (expectedRecordCount != 0)
{
var records = string.IsNullOrEmpty(timeLineRecordName) ?
mockTaskHttpClient.TimelineRecordsUpdated.Where(rec => rec.Id == parentId || rec.Id == childId).ToList() :
mockTaskHttpClient.TimelineRecordsUpdated.Where(rec => rec.Name != null && rec.Name.Equals(timeLineRecordName, StringComparison.OrdinalIgnoreCase)).ToList();
Assert.AreEqual(expectedRecordCount, records.Count);
foreach (var record in records)
{
Assert.IsNotNull(record);
Assert.AreEqual(expectedResult, record.Result);
}
}
}
