Isolate Shared Test Code (#252)

The goal of this make sure that test code is correctly organized to ensure that test suites aren't dependent on each other. * UnitTests get their own project now (renaming Microsoft.SqlTools.ServiceLayer.Test to Microsoft.SqlTools.ServiceLayer.UnitTests) which is about 90% of the changes to the files. * IntegrationTests no longer depends on UnitTests, only Test.Common * Any shared components from TestObjects that spins up a "live" connection has been moved to IntegrationTests Utility/LiveConnectionHelper.cs * The dictionary-based mock file stream factory has been moved to Test.Common since it is used by UnitTests and IntegrationTests * Added a overload that doesn't take a dictionary for when we don't care about monitoring the storage (about 90% of the time) * The RunIf* wrapper methods have been moved to Test.Common * OwnerUri and StandardQuery constants have been moved to Test.Common Constants file * Updating to latest SDK version available at https://www.microsoft.com/net/core#windowscmd * Moving unit tests to unit test folder * Changing namespaces to UnitTests * Moving some constants and shared functionality into common project, making the UnitTests reference it * Unit tests are working! * Integration tests are working * Updating automated test runs * Fixing one last broken unit test * Exposing internals for other projects * Moving edit data tests to UnitTest project * Applying refactor fixes to unit tests * Fixing flaky test that wasn't awaiting completion
2026-01-20 09:35:38 -05:00 · 2017-03-02 13:00:31 -08:00
parent f9abe5f0bd
commit 1166778249
110 changed files with 700 additions and 764 deletions
--- a/test/Microsoft.SqlTools.ServiceLayer.UnitTests/ServiceHost/AsyncQueueTests.cs
+++ b/test/Microsoft.SqlTools.ServiceLayer.UnitTests/ServiceHost/AsyncQueueTests.cs
@@ -0,0 +1,91 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.ServiceHost
+{
+    public class AsyncQueueTests
+    {
+        [Fact]
+        public async Task AsyncQueueSynchronizesAccess()
+        {
+            ConcurrentBag<int> outputItems = new ConcurrentBag<int>();
+            AsyncQueue<int> inputQueue = new AsyncQueue<int>(Enumerable.Range(0, 100));
+            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+
+            try
+            {
+                // Start 5 consumers
+                await Task.WhenAll(
+                    Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
+                    Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
+                    Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
+                    Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
+                    Task.Run(() => ConsumeItems(inputQueue, outputItems, cancellationTokenSource.Token)),
+                    Task.Run(
+                        async () =>
+                        {
+                            // Wait for a bit and then add more items to the queue
+                            await Task.Delay(250);
+
+                            foreach (var i in Enumerable.Range(100, 200))
+                            {
+                                await inputQueue.EnqueueAsync(i);
+                            }
+
+                            // Cancel the waiters
+                            cancellationTokenSource.Cancel();
+                        }));
+            }
+            catch (TaskCanceledException)
+            {
+                // Do nothing, this is expected.
+            }
+
+            // At this point, numbers 0 through 299 should be in the outputItems
+            IEnumerable<int> expectedItems = Enumerable.Range(0, 300);
+            Assert.Equal(0, expectedItems.Except(outputItems).Count());
+        }
+
+        [Fact]
+        public async Task AsyncQueueSkipsCancelledTasks()
+        {
+            AsyncQueue<int> inputQueue = new AsyncQueue<int>();
+
+            // Queue up a couple of tasks to wait for input
+            CancellationTokenSource cancellationSource = new CancellationTokenSource();
+            Task<int> taskOne = inputQueue.DequeueAsync(cancellationSource.Token);
+            Task<int> taskTwo = inputQueue.DequeueAsync();
+
+            // Cancel the first task and then enqueue a number
+            cancellationSource.Cancel();
+            await inputQueue.EnqueueAsync(1);
+
+            // Did the second task get the number?
+            Assert.Equal(TaskStatus.Canceled, taskOne.Status);
+            Assert.Equal(TaskStatus.RanToCompletion, taskTwo.Status);
+            Assert.Equal(1, taskTwo.Result);
+        }
+
+        private async Task ConsumeItems(
+            AsyncQueue<int> inputQueue,
+            ConcurrentBag<int> outputItems,
+            CancellationToken cancellationToken)
+        {
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                int consumedItem = await inputQueue.DequeueAsync(cancellationToken);
+                outputItems.Add(consumedItem);
+            }
+        }
+    }
+}