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 TestHandleUpdate()
        {
            NotificationManager notificationManager = null;
            UserCache userCache = null;
            try
            {
                // Setup the basics
                object syncRoot = new object();
                int serverPort = 30001;
                int clientPort = 30002;
                userCache = new UserCache();
                notificationManager = new NotificationManager(serverPort, clientPort, userCache, false);
                string buildKey1 = "buildkey1";
                string buildKey2 = "buildkey2";
                string username = "******";
                string hostname = "localhost";

                // Create a user that has one build building and is responsible for one other build
                User user = new User(username) {
                                                       Hostname = hostname
                                               };
                user.ActiveBuilds.Add(buildKey1);
                user.BuildsResponsibleFor.Add(buildKey2);

                // A dummy client which the notification manager will notify
                Listener listener = new Listener(IPAddress.Any, clientPort);
                Dictionary<RequestType, IRequest> requests = new Dictionary<RequestType, IRequest>();
                listener.OnCommandReceived += (sender, args) =>
                {
                    requests.Add(((IRequest)sender).Type, (IRequest)sender);
                    lock (syncRoot)
                    {
                        Monitor.Pulse(syncRoot);
                    }
                };
                listener.Start();
                Assert.That(listener.Running, Is.True);

                // Raise an update for this user and wait until all events caused have been raised
                lock (syncRoot)
                {
                    notificationManager.HandleUpdate(user, EventArgs.Empty);
                    ////Monitor.Wait(syncRoot, 5000);
                    Monitor.Wait(syncRoot, 5000);
                }

                listener.Stop();
                Assert.That(listener.Running, Is.False);

                // Test
                Assert.That(requests.ContainsKey(RequestType.BuildActive));
                BuildActiveRequest buildActiveRequest = (BuildActiveRequest)requests[RequestType.BuildActive];
                Assert.That(buildActiveRequest.IsBuildsActive, Is.True);
            }
            finally
            {
                if (notificationManager != null)
                {
                    notificationManager.Dispose();
                }

                if (userCache != null)
                {
                    userCache.Dispose();
                }
            }
        }
 public void TestStopTwiceWithoutStart()
 {
     Listener listener = new Listener(IPAddress.Any, 0);
     listener.Stop();
     Assert.That(listener.Running, Is.False);
     listener.Stop();
     Assert.That(listener.Running, Is.False);
 }
        public void TestHandleCommandForMultipleCommandsReceivedEvent()
        {
            // Setup
            int maxCommands = 200;
            int numberOfCommandsReceived = 0;
            object runLock = new object();
            int timeout = 30000;
            string hostname = "localhost";
            int port = 39191;
            Listener listener = new Listener(IPAddress.Any, port);
            ConcurrentQueue<IBuildServerNotification> actualNotifications = new ConcurrentQueue<IBuildServerNotification>();

            listener.OnCommandReceived += (sender, args) =>
            {
                lock (runLock)
                {
                    actualNotifications.Enqueue((IBuildServerNotification)sender);
                    Interlocked.Increment(ref numberOfCommandsReceived);
                    Console.WriteLine("Number of commands received: {0}/{1}", numberOfCommandsReceived, maxCommands);
                    if (numberOfCommandsReceived == maxCommands)
                    {
                        Monitor.Pulse(runLock);
                    }
                }
            };

            BuildServerNotificationType notificationType = BuildServerNotificationType.BuildBuilding;
            string projectId = "project1";
            string buildConfigId = "buildconfig1";
            string username1 = "user1";
            string username2 = "user2";
            string[] recipients = { username1, username2 };
            BuildNotification expectedBuildNotification = new BuildNotification(notificationType, projectId, buildConfigId, recipients);
            string command = Parser.Encode(expectedBuildNotification);
            listener.Start();
            Assert.That(listener.Running, Is.True);
            Console.WriteLine("Port: {0}", port);

            // Fire
            List<bool> sendResults = new List<bool>(maxCommands);
            Thread[] threads = new Thread[maxCommands];
            Console.WriteLine("Creating {0} threads", maxCommands);
            for (int i = 0; i < maxCommands; i++)
            {
                threads[i] = new Thread(() => sendResults.Add(Utils.SendCommand(hostname, port, command)));

                threads[i].Name = i.ToString(CultureInfo.InvariantCulture);
            }

            Console.WriteLine("Starting {0} threads", maxCommands);
            Parallel.ForEach(threads, thread =>
            {
                Console.WriteLine("Starting thread {0}", thread.Name);
                thread.Start();
            });

            lock (runLock)
            {
                Console.WriteLine("Waiting to receive all commands");
                Monitor.Wait(runLock, timeout);
            }

            listener.Stop();
            Assert.That(listener.Running, Is.False);
            Console.WriteLine("Total notifications received: {0}/{1}", actualNotifications.Count, maxCommands);
            Assert.That(sendResults.Contains(false), Is.False, "One or more commands could not be sent");
            Assert.That(actualNotifications.Count, Is.EqualTo(maxCommands), "Not all commands were received - test might have timed out");

            foreach (IBuildServerNotification actualNotification in actualNotifications)
            {
                Assert.That(actualNotification, Is.Not.Null);
                Assert.That(actualNotification, Is.InstanceOf(typeof(BuildNotification)));
                BuildNotification actualBuildNotification = (BuildNotification)actualNotification;
                Assert.That(actualBuildNotification.Type, Is.EqualTo(notificationType));
                Assert.That(actualBuildNotification.ProjectId.Equals(projectId));
                Assert.That(actualBuildNotification.BuildConfigId.Equals(buildConfigId));
                Assert.That(actualBuildNotification.Recipients.Length, Is.EqualTo(2));
                Assert.That(actualBuildNotification.Recipients, Is.EqualTo(recipients));
            }
        }
 public void TestStopAndStopAgain()
 {
     Listener listener = new Listener(IPAddress.Any, 0);
     listener.Start();
     Assert.That(listener.Running, Is.True);
     listener.Stop();
     Assert.That(listener.Running, Is.False);
     listener.Stop();
     Assert.That(listener.Running, Is.False);
 }