public void TestHandleCommandForPriorityAttentionRequest() { UserCache userCache = null; NotificationManager notificationManager = null; try { // Setup the notification manager object syncRoot = new object(); int serverPort = 20000; int clientPort = 20001; // If the timer's expiry (trigger) period is too fast, the test will fail in step 2. // We set this (hopefully) sufficiently slow so that we can properly test the // sequence of events. int priorityTimerPeriod = 10000; // Any user's attention required will immediately be set as a priority. TimeSpan priorityPeriod = TimeSpan.Zero; // Note: The cache's timer starts upon construction userCache = new UserCache(priorityTimerPeriod, priorityPeriod); notificationManager = new NotificationManager(serverPort, clientPort, userCache, false); // A dummy client which the notification manager will notify Listener listener = new Listener(IPAddress.Any, clientPort); // We only want the attention requests AttentionRequest attentionRequest = null; listener.OnCommandReceived += (sender, args) => { if (sender.GetType() == typeof(AttentionRequest)) { attentionRequest = (AttentionRequest)sender; } lock (syncRoot) { Monitor.Pulse(syncRoot); } }; // Create the requests and notifications string username = "******"; string hostname = "localhost"; string projectId = "project1"; string buildConfigId = "buildConfig1"; string state = BuildServerResponsibilityState.Taken; RegistrationRequest registrationRequest = new RegistrationRequest(hostname, username); ResponsibilityNotification responsibilityNotification = new ResponsibilityNotification(BuildServerNotificationType.BuildResponsibilityAssigned, projectId, buildConfigId, username, state); // Start the server and the client notificationManager.Start(); Assert.That(notificationManager.Running, Is.True); listener.Start(); Assert.That(listener.Running, Is.True); // STEP 1 // Register the dummy client with the server lock (syncRoot) { // This will cause one attention request and one build active request Utils.SendCommand(hostname, serverPort, Parser.Encode(registrationRequest)); Monitor.Wait(syncRoot); } Assert.That(attentionRequest, Is.Not.Null); Assert.That(attentionRequest.IsAttentionRequired, Is.False); Assert.That(attentionRequest.IsPriority, Is.False); // STEP 2 attentionRequest = null; lock (syncRoot) { // This will cause another attention request and another build active request notificationManager.HandleCommand(responsibilityNotification, EventArgs.Empty); Monitor.Wait(syncRoot); } Assert.That(attentionRequest, Is.Not.Null); Assert.That(attentionRequest != null && attentionRequest.IsAttentionRequired, Is.True); Assert.That(attentionRequest != null && attentionRequest.IsPriority, Is.False); // STEP 3 // The next two pulses (again for an attention and a build active request) must // be because of the timer that expired attentionRequest = null; lock (syncRoot) { Monitor.Wait(syncRoot); } // Shut down notificationManager.Stop(); Assert.That(notificationManager.Running, Is.False); listener.Stop(); Assert.That(listener.Running, Is.False); // Test Assert.That(attentionRequest, Is.Not.Null); Assert.That(attentionRequest != null && attentionRequest.IsAttentionRequired, Is.True); Assert.That(attentionRequest != null && attentionRequest.IsPriority, Is.True); } finally { if (notificationManager != null) { notificationManager.Dispose(); } if (userCache != null) { userCache.Dispose(); } } }
public void TestHandleCommandForResponsibilityNotificationRaisesCommandReceivedEvent() { // Setup Listener listener = new Listener(IPAddress.Any, 0); IBuildServerNotification actualNotification = null; listener.OnCommandReceived += delegate(object sender, EventArgs args) { actualNotification = (IBuildServerNotification)sender; }; BuildServerNotificationType notificationType = BuildServerNotificationType.BuildResponsibilityAssigned; string projectId = "project1"; string buildConfigId = "buildconfig1"; string username = "******"; string state = BuildServerResponsibilityState.Taken; ResponsibilityNotification actualResponsibilityNotification = new ResponsibilityNotification(notificationType, projectId, buildConfigId, username, state); string command = Parser.Encode(actualResponsibilityNotification); // Fire listener.HandleCommand(command); // Test Assert.That(actualNotification, Is.Not.Null); Assert.That(actualNotification, Is.InstanceOf(typeof(ResponsibilityNotification))); ResponsibilityNotification expectedResponsibilityNotification = (ResponsibilityNotification)actualNotification; Assert.That(expectedResponsibilityNotification.Type, Is.EqualTo(notificationType)); Assert.That(expectedResponsibilityNotification.ProjectId.Equals(projectId)); Assert.That(expectedResponsibilityNotification.BuildConfigId.Equals(buildConfigId)); Assert.That(expectedResponsibilityNotification.Recipient, Is.EqualTo(username)); Assert.That(expectedResponsibilityNotification.State, Is.EqualTo(state)); }
public void TestHandleResponsibilityNotification() { UserCache userCache = null; NotificationManager notificationManager = null; try { userCache = new UserCache(); notificationManager = new NotificationManager(0, 0, userCache, false); string username = "******"; BuildServerNotificationType notificationType = BuildServerNotificationType.BuildResponsibilityAssigned; string state = BuildServerResponsibilityState.Taken; string projectId = "project1"; string buildConfigId = "buildconfig1"; IBuildServerNotification buildServerNotification = new ResponsibilityNotification(notificationType, projectId, buildConfigId, username, state); string buildKey = Utils.CreateBuildKey(buildServerNotification); notificationManager.HandleCommand(buildServerNotification, EventArgs.Empty); User user = userCache.GetUser(username); Assert.That(user.Username, Is.EqualTo(username)); Assert.That(user.BuildsResponsibleFor.Contains(buildKey)); } finally { if (notificationManager != null) { notificationManager.Dispose(); } if (userCache != null) { userCache.Dispose(); } } }
public void TestUpdateUserBothResponsibleAndHasActiveBuild() { UserCache userCache = null; try { // Setup userCache = new UserCache(); User actualUser = null; userCache.OnUpdate += delegate(object sender, EventArgs args) { actualUser = (User)sender; }; string username = "******"; string projectId = "project1"; // First notification BuildServerNotificationType notificationType1 = BuildServerNotificationType.BuildResponsibilityAssigned; string buildConfigId1 = "buildconfig1"; string state = BuildServerResponsibilityState.Taken; IBuildServerNotification notification1 = new ResponsibilityNotification(notificationType1, projectId, buildConfigId1, username, state); userCache.Update(notification1); // Second notification BuildServerNotificationType notificationType2 = BuildServerNotificationType.BuildBuilding; string buildConfigId2 = "buildconfig2"; string[] recipients = { username }; IBuildServerNotification notification2 = new BuildNotification(notificationType2, projectId, buildConfigId2, recipients); userCache.Update(notification2); // Test Assert.That(actualUser, NUnit.Framework.Is.Not.Null); Assert.That(actualUser.Username, NUnit.Framework.Is.EqualTo(username)); Assert.That(actualUser.IsBuildActive(), NUnit.Framework.Is.True); Assert.That(actualUser.IsAttentionRequired(), NUnit.Framework.Is.True); } finally { if (userCache != null) { userCache.Dispose(); } } }
public void TestUpdateWithResponsibilityTaken([Values(BuildServerNotificationType.BuildResponsibilityAssigned, BuildServerNotificationType.TestResponsibilityAssigned)] BuildServerNotificationType notificationType) { UserCache userCache = null; try { string projectId = "project1"; string buildConfigId = "buildconfig1"; string username = "******"; string recipients = username; string state = "TAKEN"; IBuildServerNotification notification = new ResponsibilityNotification(notificationType, projectId, buildConfigId, recipients, state); userCache = new UserCache(); userCache.Update(notification); User user = userCache.GetUser(username); Assert.That(user.IsAttentionRequired()); } finally { if (userCache != null) { userCache.Dispose(); } } }
public void TestUpdateNotificationForResponsibleForBuild() { UserCache userCache = null; try { // Setup userCache = new UserCache(); User actualUser = null; userCache.OnUpdate += delegate(object sender, EventArgs args) { actualUser = (User)sender; }; BuildServerNotificationType notificationType = BuildServerNotificationType.BuildResponsibilityAssigned; string projectId = "project1"; string buildConfigId = "buildconfig1"; string username = "******"; string state = BuildServerResponsibilityState.Taken; IBuildServerNotification expectedNotification = new ResponsibilityNotification(notificationType, projectId, buildConfigId, username, state); // Execute userCache.Update(expectedNotification); // Test Assert.That(actualUser, NUnit.Framework.Is.Not.Null); Assert.That(actualUser.Username, NUnit.Framework.Is.EqualTo(username)); Assert.That(actualUser.IsBuildActive(), NUnit.Framework.Is.False); Assert.That(actualUser.IsAttentionRequired(), NUnit.Framework.Is.True); } finally { if (userCache != null) { userCache.Dispose(); } } }
public void TestUpdateSameUserMadeResponsibleTwiceForSameBuild() { UserCache userCache = null; try { // Shared string projectId = "project1"; string buildConfigId = "buildconfig1"; userCache = new UserCache(); // Events BuildServerNotificationType notificationType = BuildServerNotificationType.BuildResponsibilityAssigned; string username = "******"; IBuildServerNotification notification = new ResponsibilityNotification(notificationType, projectId, buildConfigId, username, BuildServerResponsibilityState.Taken); string buildKey = Utils.CreateBuildKey(notification); userCache.Update(notification); userCache.Update(notification); // Test Assert.That(userCache.GetUser(username).BuildsResponsibleFor.Count, NUnit.Framework.Is.EqualTo(1)); Assert.That(userCache.GetUser(username).BuildsResponsibleFor.Contains(buildKey)); } finally { if (userCache != null) { userCache.Dispose(); } } }
public void TestUpdateNoMultipleUsersResponsibleForBuild() { UserCache userCache = null; try { // Shared string projectId = "project1"; string buildConfigId = "buildconfig1"; userCache = new UserCache(); // User 1 gets assigned BuildServerNotificationType notificationType = BuildServerNotificationType.BuildResponsibilityAssigned; string username1 = "user1"; IBuildServerNotification notification1 = new ResponsibilityNotification(notificationType, projectId, buildConfigId, username1, BuildServerResponsibilityState.Taken); userCache.Update(notification1); // User 2 gets assigned string username2 = "user2"; IBuildServerNotification notification2 = new ResponsibilityNotification(notificationType, projectId, buildConfigId, username2, BuildServerResponsibilityState.Taken); userCache.Update(notification2); // User 2 but not user 1 must be responsible User user1 = userCache.GetUser(username1); Assert.That(user1.IsAttentionRequired(), NUnit.Framework.Is.False); User user2 = userCache.GetUser(username2); Assert.That(user2.IsAttentionRequired()); } finally { if (userCache != null) { userCache.Dispose(); } } }
public void TestPriorityTimerWithResponsibilityNotification() { UserCache userCache = null; try { object syncRoot = new object(); int numberOfEvents = 0; int priorityTimerPeriod = 1000; TimeSpan priorityPeriod = TimeSpan.Zero; string projectId = "project1"; string buildConfigId = "buildConfig1"; string username = "******"; string state = BuildServerResponsibilityState.Taken; userCache = new UserCache(priorityTimerPeriod, priorityPeriod); User user = null; userCache.OnUpdate += (sender, args) => { numberOfEvents++; if (numberOfEvents != 2) { return; } user = (User)sender; lock (syncRoot) { Monitor.Pulse(syncRoot); } }; ResponsibilityNotification notification = new ResponsibilityNotification(BuildServerNotificationType.BuildResponsibilityAssigned, projectId, buildConfigId, username, state); userCache.Update(notification); lock (syncRoot) { Monitor.Wait(syncRoot, 2 * priorityTimerPeriod); } Assert.That(numberOfEvents, NUnit.Framework.Is.EqualTo(2)); Assert.That(user, NUnit.Framework.Is.Not.Null); Assert.That(user.BuildsResponsibleFor.Count, NUnit.Framework.Is.EqualTo(1)); Assert.That(user.ActiveBuilds.Count, NUnit.Framework.Is.EqualTo(0)); Assert.That(user.IsAttentionPriority, NUnit.Framework.Is.True); } finally { if (userCache != null) { userCache.Dispose(); } } }
public void TestUpdateWithResponsibilityTakenUserExists() { UserCache userCache = null; try { BuildServerNotificationType notificationType = BuildServerNotificationType.BuildResponsibilityAssigned; string projectId = "project1"; string buildConfigId = "buildconfig1"; string recipient = "user1"; string state = BuildServerResponsibilityState.Taken; IBuildServerNotification notification = new ResponsibilityNotification(notificationType, projectId, buildConfigId, recipient, state); userCache = new UserCache(); userCache.Update(notification); state = BuildServerResponsibilityState.Fixed; notification = new ResponsibilityNotification(notificationType, projectId, buildConfigId, recipient, state); userCache.Update(notification); User user = userCache.GetUser(recipient); Assert.That(user.IsAttentionRequired(), NUnit.Framework.Is.False); } finally { if (userCache != null) { userCache.Dispose(); } } }
public void TestEncodeResponsibilityNotification() { // Construct notification object BuildServerNotificationType notificationType = BuildServerNotificationType.BuildResponsibilityAssigned; string projectId = "project1"; string buildConfigId = "buildconfig1"; string username = "******"; string state = BuildServerResponsibilityState.Taken; ResponsibilityNotification notification = new ResponsibilityNotification(notificationType, projectId, buildConfigId, username, state); // Manually construct a packet string notificationPart = Field.NotificationTypeId + Packet.FieldSeparator + ((int)notificationType).ToString(CultureInfo.InvariantCulture) + Packet.CommandSeparator; string projectPart = Field.ProjectId + Packet.FieldSeparator + projectId + Packet.CommandSeparator; string buildConfigPart = Field.BuildConfigId + Packet.FieldSeparator + buildConfigId + Packet.CommandSeparator; string recipientPart = Field.ResponsibleUsername + Packet.FieldSeparator + username + Packet.CommandSeparator; string statePart = Field.ResponsibilityState + Packet.FieldSeparator + state + Packet.PacketTerminator; string expectedCommand = notificationPart + projectPart + buildConfigPart + recipientPart + statePart; // Test string actualCommand = Parser.Encode(notification); Assert.That(actualCommand.Equals(expectedCommand)); }
/// <summary> /// Updates the builds the user is responsible for. /// </summary> /// <param name="buildKey">The build key.</param> /// <param name="responsibilityNotification">The responsibility notification.</param> /// <param name="user">The user.</param> private void UpdateUserBuildsResponsibleFor(string buildKey, ResponsibilityNotification responsibilityNotification, ref User user) { if (Utils.IsAttentionRequired(responsibilityNotification.Type, responsibilityNotification.State)) { if (!user.BuildsResponsibleFor.Contains(buildKey)) { // Only one user can be responsible for a given build key foreach (User otherUser in this.userCache.Values.Where(x => x.BuildsResponsibleFor.Contains(buildKey))) { otherUser.BuildsResponsibleFor.Remove(buildKey); if (otherUser.BuildsResponsibleFor.Count == 0) { CancelPriority(otherUser); } } if (user.BuildsResponsibleFor.Count == 0) { user.AttentionFirstRequired = DateTime.Now; } // We could be removing the build key we just added, so this needs to happen afterwards user.BuildsResponsibleFor.Add(buildKey); } } else { user.BuildsResponsibleFor.Remove(buildKey); if (user.BuildsResponsibleFor.Count == 0) { CancelPriority(user); } } }