Merge branch 'master' into 84

Author: MikhailArkhipov

build/Common.Build.Core.settings

@@ -65,7 +65,7 @@
     <BuildOutputRoot Condition="'$(BuildOutputRoot)' == ''">$(BuildRoot)output\</BuildOutputRoot>
     <BuildOutputRoot Condition="!HasTrailingSlash($(BuildOutputRoot))">$(BuildOutputRoot)\</BuildOutputRoot>
 
-    <OutputPath Condition="'$(OutputPath)' == ''">$(BuildOutputRoot)bin\</OutputPath>
+    <OutputPath Condition="'$(OutputPath)' == ''">$(BuildOutputRoot)bin\$(Configuration)\</OutputPath>
     <OutputPath Condition="!HasTrailingSlash($(OutputPath))">$(OutputPath)\</OutputPath>
 
     <BinariesOutputPath Condition="'$(BinariesOutputPath)' == ''">$(BuildOutputRoot)bin\binaries\</BinariesOutputPath>

src/Analysis/Engine/Test/AnalysisTest.cs

@@ -359,18 +359,13 @@ public async Task AstTypeStubPaths_NoStubs() {
                     server, 
                     "import Package.Module\n\nc = Package.Module.Class()",
                     new AnalysisLimits { UseTypeStubPackages = false },
-                    searchPaths: Enumerable.Empty<string>(),
+                    searchPaths: new[] { TestData.GetPath("TestData\\AstAnalysis") },
                     stubPaths: Enumerable.Empty<string>());
 
-                var type = analysis.Should().HavePythonModuleVariable("Package")
-                    .Which.Should().HaveNestedModule("Module")
-                    .Which.Should().HaveClass("Class")
-                    .Which;
+                analysis.Should().HavePythonModuleVariable("Package");
 
                 analysis.Should().HaveVariable("c")
                     .WithValue<IBuiltinInstanceInfo>()
-                    .Which.Should().HaveMemberType(PythonMemberType.Instance)
-                    .And.HavePythonType(type)
                     .Which.Should().HaveMembers("untyped_method", "inferred_method")
                     .And.NotHaveMembers("typed_method", "typed_method_2");
             }
@@ -388,9 +383,7 @@ public async Task AstTypeStubPaths_MergeStubs() {
                     searchPaths: new[] { TestData.GetPath("TestData\\AstAnalysis") },
                     stubPaths: Enumerable.Empty<string>());
 
-                analysis.Should().HavePythonModuleVariable("Package")
-                    .Which.Should().HaveNestedModule("Module")
-                    .Which.Should().HaveMultipleTypesMember("Class");
+                analysis.Should().HavePythonModuleVariable("Package");
 
                 analysis.Should().HaveVariable("c")
                     .WithValue<IBuiltinInstanceInfo>()
@@ -410,9 +403,7 @@ public async Task AstTypeStubPaths_MergeStubsPath() {
                     searchPaths: new[] { TestData.GetPath("TestData\\AstAnalysis") },
                     stubPaths: new[] { TestData.GetPath("TestData\\AstAnalysis\\Stubs") });
 
-                analysis.Should().HavePythonModuleVariable("Package")
-                    .Which.Should().HaveNestedModule("Module")
-                    .Which.Should().HaveMultipleTypesMember("Class"); // member information comes from multiple sources
+                analysis.Should().HavePythonModuleVariable("Package"); // member information comes from multiple sources
 
                 analysis.Should().HaveVariable("c")
                     .WithValue<IBuiltinInstanceInfo>()
@@ -449,16 +440,14 @@ private async Task<IModuleAnalysis> GetStubBasedAnalysis(
             AnalysisLimits limits,
             IEnumerable<string> searchPaths,
             IEnumerable<string> stubPaths) {
-            var uri = await server.OpenDefaultDocumentAndGetUriAsync(code);
-            await server.GetAnalysisAsync(uri);
 
             if (limits != null) {
                 server.Analyzer.Limits = limits;
             }
             server.Analyzer.SetSearchPaths(searchPaths);
             server.Analyzer.SetTypeStubPaths(stubPaths);
 
-            server.EnqueueItem(uri);
+            var uri = await server.OpenDefaultDocumentAndGetUriAsync(code);
             return await server.GetAnalysisAsync(uri);
         }
 

src/Analysis/Engine/Test/AstAnalysisTests.cs

@@ -63,6 +63,14 @@ public AndConstraint<TAssertions> HaveType(BuiltinTypeId typeId, string because
             return new AndConstraint<TAssertions>((TAssertions)this);
         }
 
+        public AndConstraint<TAssertions> HaveDescription(string description, string because = "", params object[] reasonArgs) {
+            Execute.Assertion.ForCondition(string.Equals(Subject.Description, description, StringComparison.Ordinal))
+                .BecauseOf(because, reasonArgs)
+                .FailWith($"Expected {GetName()} to be {description}{{reason}}, but it is {Subject.Description}.");
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
         public AndConstraint<TAssertions> HaveOnlyMembers(params string[] memberNames)
             => HaveOnlyMembers(memberNames, string.Empty);
 
@@ -137,7 +145,7 @@ public AndConstraint<TAssertions> HaveMemberType(PythonMemberType memberType, st
         }
 
         public AndWhichConstraint<TAssertions, IPythonType> HavePythonType(IPythonType pythonType, string because = "", params object[] reasonArgs) {
-            Execute.Assertion.ForCondition(Subject.PythonType == pythonType)
+            Execute.Assertion.ForCondition(Equals(Subject.PythonType, pythonType))
                 .BecauseOf(because, reasonArgs)
                 .FailWith(Subject.PythonType != null
                     ? $"Expected {GetName()} to be {GetQuotedName(pythonType)}{{reason}}, but it is {GetQuotedName(Subject.PythonType)}."

src/Analysis/Engine/Test/FluentAssertions/AnalysisValueAssertions.cs

@@ -9,11 +9,12 @@
 // THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
 // OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
 // IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-// MERCHANTABLITY OR NON-INFRINGEMENT.
+// MERCHANTABILITY OR NON-INFRINGEMENT.
 //
 // See the Apache Version 2.0 License for specific language governing
 // permissions and limitations under the License.
 
+using System;
 using System.Diagnostics.CodeAnalysis;
 using FluentAssertions;
 using FluentAssertions.Execution;
@@ -29,6 +30,17 @@ public SignatureHelpAssertions(SignatureHelp subject) {
 
         protected override string Identifier => nameof(SignatureHelp);
 
+        public AndWhichConstraint<SignatureHelpAssertions, SignatureInformation> OnlyHaveSignature(string signature, string because = "", params object[] reasonArgs) {
+            var constraint = HaveSingleSignature();
+            var actual = constraint.Which.label;
+
+            Execute.Assertion.ForCondition(string.Equals(actual, signature, StringComparison.Ordinal))
+                .BecauseOf(because, reasonArgs)
+                .FailWith($"Expected SignatureHelp to have single signature '{signature}'{{reason}}, but it has '{actual}'.");
+
+            return constraint;
+        }
+
         public AndWhichConstraint<SignatureHelpAssertions, SignatureInformation> HaveSingleSignature(string because = "", params object[] reasonArgs) {
             NotBeNull(because, reasonArgs);
 

src/Analysis/Engine/Test/FluentAssertions/SignatureHelpAssertions.cs

@@ -21,6 +21,7 @@
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 using Microsoft.Python.LanguageServer;
+using Microsoft.PythonTools.Analysis.Documentation;
 
 namespace Microsoft.PythonTools.Analysis.FluentAssertions {
     [ExcludeFromCodeCoverage]
@@ -59,5 +60,23 @@ public AndConstraint<SignatureInformationAssertions> OnlyHaveParameterLabels(IEn
 
             return new AndConstraint<SignatureInformationAssertions>(this);
         }
+        
+        public AndConstraint<SignatureInformationAssertions> HaveMarkdownDocumentation(string documentation, string because = "", params object[] reasonArgs) {
+            NotBeNull(because, reasonArgs);
+
+            var errorMessage = Subject.documentation == null
+                ? $"Expected signature '{Subject.label}' to have markdown documentation {documentation}{{reason}}, but it has no documentation"
+                : Subject.documentation.kind != MarkupKind.Markdown
+                    ? $"Expected signature '{Subject.label}' to have markdown documentation '{documentation}'{{reason}}, but it has {Subject.documentation.kind} documentation"
+                    : !string.Equals(Subject.documentation.value, documentation)
+                        ? $"Expected signature '{Subject.label}' to have markdown documentation '{documentation}'{{reason}}, but it has '{Subject.documentation.value}'"
+                        : null;
+
+            Execute.Assertion.ForCondition(errorMessage == null)
+                .BecauseOf(because, reasonArgs)
+                .FailWith(errorMessage);
+
+            return new AndConstraint<SignatureInformationAssertions>(this);
+        }
     }
 }

src/Analysis/Engine/Test/FluentAssertions/SignatureInformationAssertions.cs

@@ -0,0 +1,25 @@
+// Python Tools for Visual Studio
+// Copyright(c) Microsoft Corporation
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the License); you may not use
+// this file except in compliance with the License. You may obtain a copy of the
+// License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
+// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+// MERCHANTABILITY OR NON-INFRINGEMENT.
+//
+// See the Apache Version 2.0 License for specific language governing
+// permissions and limitations under the License.
+
+using System;
+
+namespace Microsoft.Python.UnitTests.Core.MSTest {
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+    public class MatrixColumnAttribute : VectorAttribute {
+        public MatrixColumnAttribute(object data) : base(data) { }
+        public MatrixColumnAttribute(object data, params object[] moreData) : base(data, moreData) { }
+    }
+}

src/UnitTests/Core/Impl/MSTest/MatrixColumnAttribute.cs

@@ -0,0 +1,25 @@
+// Python Tools for Visual Studio
+// Copyright(c) Microsoft Corporation
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the License); you may not use
+// this file except in compliance with the License. You may obtain a copy of the
+// License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
+// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+// MERCHANTABILITY OR NON-INFRINGEMENT.
+//
+// See the Apache Version 2.0 License for specific language governing
+// permissions and limitations under the License.
+
+using System;
+
+namespace Microsoft.Python.UnitTests.Core.MSTest {
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+    public class MatrixRowAttribute : VectorAttribute {
+        public MatrixRowAttribute(object data) : base(data) { }
+        public MatrixRowAttribute(object data, params object[] moreData) : base(data, moreData) { }
+    }
+}

src/UnitTests/Core/Impl/MSTest/MatrixRowAttribute.cs

@@ -0,0 +1,58 @@
+// Python Tools for Visual Studio
+// Copyright(c) Microsoft Corporation
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the License); you may not use
+// this file except in compliance with the License. You may obtain a copy of the
+// License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
+// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+// MERCHANTABILITY OR NON-INFRINGEMENT.
+//
+// See the Apache Version 2.0 License for specific language governing
+// permissions and limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Microsoft.Python.UnitTests.Core.MSTest {
+    [AttributeUsage(AttributeTargets.Method)]
+    public class MatrixTestMethodAttribute : DataTestMethodAttribute, ITestDataSource {
+        private readonly Dictionary<object[], string> _names = new Dictionary<object[], string>();
+
+        public string NameFormat { get; set; }
+
+        public MatrixTestMethodAttribute() {
+            NameFormat = "{0} ({1}) x ({2})";
+        }
+
+        public IEnumerable<object[]> GetData(MethodInfo methodInfo) {
+            var rows = methodInfo.GetCustomAttributes<MatrixRowAttribute>();
+            var columns = methodInfo.GetCustomAttributes<MatrixColumnAttribute>().ToArray();
+            foreach (var row in rows) {
+                foreach (var column in columns) {
+                    var data = new object[row.Data.Length + column.Data.Length];
+                    Array.Copy(row.Data, 0, data, 0, row.Data.Length);
+                    Array.Copy(column.Data, 0, data, row.Data.Length, column.Data.Length);
+
+                    var rowName = row.DisplayName ?? string.Join(", ", row.Data);
+                    var columnName = column.DisplayName ?? string.Join(", ", column.Data);
+                    var name = string.Format(CultureInfo.CurrentCulture, NameFormat, methodInfo.Name, rowName, columnName);
+                    _names[data] = name;
+
+                    yield return data;
+                }
+            }
+        }
+
+        public string GetDisplayName(MethodInfo methodInfo, object[] data) {
+            return _names.TryGetValue(data, out var name) ? name : methodInfo.Name + new Random().Next();
+        }
+    }
+}

src/UnitTests/Core/Impl/MSTest/MatrixTestMethodAttribute.cs

@@ -0,0 +1,39 @@
+// Python Tools for Visual Studio
+// Copyright(c) Microsoft Corporation
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the License); you may not use
+// this file except in compliance with the License. You may obtain a copy of the
+// License at http://www.apache.org/licenses/LICENSE-2.0
+//
+// THIS CODE IS PROVIDED ON AN  *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS
+// OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
+// IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+// MERCHANTABILITY OR NON-INFRINGEMENT.
+//
+// See the Apache Version 2.0 License for specific language governing
+// permissions and limitations under the License.
+
+using System;
+
+namespace Microsoft.Python.UnitTests.Core.MSTest {
+    public class VectorAttribute : Attribute {
+        public VectorAttribute(object data) {
+            Data = new[] {data};
+        }
+
+        public VectorAttribute(object data, params object[] moreData) {
+            if (moreData == null) {
+                moreData = new object[1];
+            }
+
+            Data = new object[moreData.Length + 1];
+            Data[0] = data;
+            Array.Copy(moreData, 0, Data, 1, moreData.Length);
+        }
+
+        public object[] Data { get; }
+
+        public string DisplayName { get; set; }
+    }
+}