public static Tuple<TestWorkspace, EnvDTE.FileCodeModel> CreateWorkspaceAndFileCodeModel(string file)
{
var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromFile(file, exportProvider: VisualStudioTestExportProvider.ExportProvider);
try
{
var project = workspace.CurrentSolution.Projects.Single();
var document = project.Documents.Single().Id;
var componentModel = new MockComponentModel(workspace.ExportProvider);
var serviceProvider = new MockServiceProvider(componentModel);
WrapperPolicy.s_ComWrapperFactory = MockComWrapperFactory.Instance;
var visualStudioWorkspaceMock = new MockVisualStudioWorkspace(workspace);
var state = new CodeModelState(serviceProvider, project.LanguageServices, visualStudioWorkspaceMock);
var codeModel = FileCodeModel.Create(state, null, document, new MockTextManagerAdapter()).Handle;
return Tuple.Create(workspace, (EnvDTE.FileCodeModel)codeModel);
}
catch
{
// We threw during creation of the FileCodeModel. Make sure we clean up our workspace or else we leak it
workspace.Dispose();
throw;
}
}
private static MockServiceProvider CreateServiceProvider()
{
var serviceProviderOptions = new MockServiceProviderOptions
{
SettingsPropertyStore = new DictionaryPropertyStore(),
HostInfo = new HostInfo(Guid.NewGuid(), new HostName("myhost"), IPAddress.Parse("11.22.33.44")),
ConnectionInfo = new ConnectionInfo(IPAddress.Parse("22.33.44.55"), new IPNetwork(IPAddress.Parse("22.33.44.00"), 24)),
DhcpInfo = new DhcpInfo(IPAddress.Parse("100.101.102.103"), IPAddress.Parse("200.201.202.203"), "my-domain-name"),
ExternalAddress = IPAddress.Parse("50.51.52.53")
};
var serviceProvider = new MockServiceProvider(serviceProviderOptions);
return serviceProvider;
}
/// <summary>
/// Sets up a limited service provider which can be used for testing.
///
/// This will not include many of the services which are typically available in
/// VS but is suitable for simple test cases which need just some base functionality.
/// </summary>
public static MockServiceProvider CreateMockServiceProvider(
bool suppressTaskProvider = true
)
{
var componentModel = new MockComponentModel();
var serviceProvider = new MockServiceProvider(componentModel);
componentModel.AddExtension(
typeof(IErrorProviderFactory),
() => new MockErrorProviderFactory()
);
componentModel.AddExtension(
typeof(IContentTypeRegistryService),
CreateContentTypeRegistryService
);
componentModel.AddExtension(
typeof(IInteractiveWindowCommandsFactory),
() => new MockInteractiveWindowCommandsFactory()
);
var optService = new Lazy <MockInterpreterOptionsService>(() => new MockInterpreterOptionsService());
componentModel.AddExtension <IInterpreterRegistryService>(() => optService.Value);
componentModel.AddExtension <IInterpreterOptionsService>(() => optService.Value);
var editorServices = CreatePythonEditorServices(serviceProvider, componentModel);
componentModel.AddExtension(() => editorServices);
if (suppressTaskProvider)
{
serviceProvider.AddService(typeof(ErrorTaskProvider), null, true);
serviceProvider.AddService(typeof(CommentTaskProvider), null, true);
}
else
{
serviceProvider.AddService(typeof(ErrorTaskProvider), ErrorTaskProvider.CreateService, true);
serviceProvider.AddService(typeof(CommentTaskProvider), CommentTaskProvider.CreateService, true);
}
serviceProvider.AddService(typeof(UIThreadBase), new MockUIThread());
var optionsService = new MockPythonToolsOptionsService();
serviceProvider.AddService(typeof(IPythonToolsOptionsService), optionsService, true);
var ptvsService = new PythonToolsService(serviceProvider);
serviceProvider.AddService(typeof(PythonToolsService), ptvsService);
return(serviceProvider);
}
public void GedInjectedService_GetsValueFromServiceInjector()
{
var service = new MockService();
var serviceInjector = new MockServiceInjector <IMockService>()
{
Service = service
};
var serviceProvider = new MockServiceProvider()
.With <IServiceInjector <IMockService> >(serviceInjector);
var result = serviceProvider.GetInjectedService <IMockService>();
Assert.Equal(service, result);
}
public void AddService_PromoteServiceInstanceWithValidParentProvider_AddsToParent()
{
var serviceInstance = new object();
var parentContainer = new ServiceContainer();
var parentProvider = new MockServiceProvider();
parentProvider.Setup(typeof(IServiceContainer), parentContainer);
parentProvider.Setup(typeof(object), null);
var container = new ServiceContainer(parentProvider);
container.AddService(typeof(object), serviceInstance, promote: true);
Assert.Null(container.GetService(typeof(object)));
Assert.Same(serviceInstance, parentContainer.GetService(typeof(object)));
}
public void TestOptionLoading()
{
using var workspace = TestWorkspace.CreateCSharp("");
var optionSet = workspace.Options.WithChangedOption(CSharpFormattingOptions.SpacingAfterMethodDeclarationName, true);
var optionStore = new OptionStore(optionSet, Enumerable.Empty <IOption>());
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
using var viewModel = new SpacingViewModel(optionStore, serviceProvider);
// Use the first item's preview.
var checkbox = viewModel.Items.OfType <CheckBoxOptionViewModel>().Where(c => c.Option == CSharpFormattingOptions.SpacingAfterMethodDeclarationName).First();
Assert.True(checkbox.IsChecked);
}
public void InitializeTest()
{
var serviceProvider = new MockServiceProvider();
UpdateSolutionListener target = new UpdateSolutionListener(serviceProvider);
target.Initialize();
PrivateObject updateSolutionListener = new PrivateObject(target, new PrivateType(typeof(UpdateSolutionListener)));
uint expected = 1;
Assert.AreEqual(expected, updateSolutionListener.GetFieldOrProperty("eventsCookie"));
}
/// <summary>
/// Sets up a limited service provider which can be used for testing.
///
/// This will not include many of the services which are typically available in
/// VS but is suitable for simple test cases which need just some base functionality.
/// </summary>
public static MockServiceProvider CreateMockServiceProvider(
bool suppressTaskProvider = false
)
{
var serviceProvider = new MockServiceProvider();
serviceProvider.ComponentModel.AddExtension(
typeof(IErrorProviderFactory),
() => new MockErrorProviderFactory()
);
serviceProvider.ComponentModel.AddExtension(
typeof(IContentTypeRegistryService),
CreateContentTypeRegistryService
);
serviceProvider.ComponentModel.AddExtension(
typeof(IInteractiveWindowCommandsFactory),
() => new MockInteractiveWindowCommandsFactory()
);
var optService = new Lazy <MockInterpreterOptionsService>(() => new MockInterpreterOptionsService());
serviceProvider.ComponentModel.AddExtension <IInterpreterRegistryService>(() => optService.Value);
serviceProvider.ComponentModel.AddExtension <IInterpreterOptionsService>(() => optService.Value);
var analysisEntryServiceCreator = new Lazy <AnalysisEntryService>(() => new AnalysisEntryService(serviceProvider));
serviceProvider.ComponentModel.AddExtension <IAnalysisEntryService>(() => analysisEntryServiceCreator.Value);
serviceProvider.ComponentModel.AddExtension(() => analysisEntryServiceCreator.Value);
if (suppressTaskProvider)
{
serviceProvider.AddService(typeof(ErrorTaskProvider), null, true);
serviceProvider.AddService(typeof(CommentTaskProvider), null, true);
}
else
{
serviceProvider.AddService(typeof(ErrorTaskProvider), CreateTaskProviderService, true);
serviceProvider.AddService(typeof(CommentTaskProvider), CreateTaskProviderService, true);
}
serviceProvider.AddService(typeof(UIThreadBase), new MockUIThread());
var optionsService = new MockPythonToolsOptionsService();
serviceProvider.AddService(typeof(IPythonToolsOptionsService), optionsService, true);
var ptvsService = new PythonToolsService(serviceProvider);
serviceProvider.AddService(typeof(PythonToolsService), ptvsService);
return(serviceProvider);
}
public void InterpreterReferenceUpgrade()
{
// PTVS 3.0 changed interpreter ID format.
var factory = new PythonProjectFactory(null);
var sp = new MockServiceProvider();
sp.Services[typeof(SVsQueryEditQuerySave).GUID] = null;
sp.Services[typeof(SVsActivityLog).GUID] = new MockActivityLog();
factory.Site = sp;
var upgrade = (IVsProjectUpgradeViaFactory)factory;
foreach (var testCase in new[] {
new { Name = "CPythonInterpreterReference.pyproj", Expected = 1, Id = "Global|PythonCore|3.5-32" },
new { Name = "UnknownInterpreterReference.pyproj", Expected = 1, Id = (string)null },
})
{
int actual;
Guid factoryGuid;
string newLocation;
var project = TestData.GetPath("TestData\\ProjectUpgrade\\" + testCase.Name);
using (FileUtils.Backup(project)) {
var hr = upgrade.UpgradeProject(
project,
0u, // no backups
null,
out newLocation,
null,
out actual,
out factoryGuid
);
Assert.AreEqual(0, hr, string.Format("Wrong HR for {0}", testCase.Name));
Assert.AreEqual(testCase.Expected, actual, string.Format("Wrong result for {0}", testCase.Name));
Assert.AreEqual(project, newLocation, string.Format("Wrong location for {0}", testCase.Name));
var content = File.ReadAllText(project);
if (testCase.Id == null)
{
Assert.IsFalse(content.Contains("<InterpreterReference "), "Found <InterpreterReference> in " + content);
}
else
{
AssertUtil.Contains(content, "<InterpreterReference Include=\"{0}\" />".FormatInvariant(testCase.Id));
}
Assert.AreEqual(Guid.Empty, factoryGuid);
}
}
}
public static IEnumerable <object[]> AddService_TypeServiceCreatorCallbackBool_TestData()
{
var nullServiceProvider = new MockServiceProvider();
nullServiceProvider.Setup(typeof(IServiceContainer), null);
nullServiceProvider.Setup(typeof(object), null);
nullServiceProvider.Setup(typeof(int), null);
var invalidServiceProvider = new MockServiceProvider();
invalidServiceProvider.Setup(typeof(IServiceContainer), new object());
invalidServiceProvider.Setup(typeof(object), null);
invalidServiceProvider.Setup(typeof(int), null);
var validServiceProvider = new MockServiceProvider();
validServiceProvider.Setup(typeof(IServiceContainer), new ServiceContainer());
validServiceProvider.Setup(typeof(object), null);
validServiceProvider.Setup(typeof(int), null);
var o = new object();
ServiceCreatorCallback callback = (container, serviceType) => "abc";
ServiceCreatorCallback nullCallback = (container, serviceType) => null;
foreach (bool promote in new bool[] { true, false })
{
foreach (IServiceProvider parentProvider in new object[] { null, nullServiceProvider, invalidServiceProvider, validServiceProvider })
{
if (promote && parentProvider == validServiceProvider)
{
continue;
}
yield return(new object[] { parentProvider, typeof(object), callback, promote, "abc" });
yield return(new object[] { parentProvider, typeof(string), callback, promote, "abc" });
yield return(new object[] { parentProvider, typeof(int), callback, promote, null });
yield return(new object[] { parentProvider, typeof(object), nullCallback, promote, null });
yield return(new object[] { parentProvider, typeof(int), nullCallback, promote, null });
}
var customServiceProvider = new MockServiceProvider();
customServiceProvider.Setup(typeof(IServiceContainer), null);
customServiceProvider.Setup(typeof(int), o);
yield return(new object[] { customServiceProvider, typeof(int), callback, promote, o });
}
}
public async Task Build_BuildsTheOverallPipeline()
{
var serviceProvider = new MockServiceProvider();
var routeBuilder = new RouteBuilder(serviceProvider);
var routerCallList = new List <string>();
var routerCallContextList = new List <RouteContext>();
routeBuilder.AddRouter(next =>
{
return(async context =>
{
routerCallList.Add("First");
routerCallContextList.Add(context);
var nextViewInfo = await next(context);
var viewInfo = new ViewInfo(string.Concat("Alpha ", nextViewInfo.View));
return viewInfo;
});
});
routeBuilder.AddRouter(next =>
{
return(context =>
{
routerCallList.Add("Second");
routerCallContextList.Add(context);
var viewInfo = new ViewInfo("Beta");
return Task.FromResult(viewInfo);
});
});
routeBuilder.AddRouter(next =>
{
return(context =>
{
routerCallList.Add("Third");
routerCallContextList.Add(context);
return next(context);
});
});
var routeContext = new RouteContext();
var router = routeBuilder.Build();
var result = await router(routeContext);
Assert.Equal(new string[] { "First", "Second" }, routerCallList);
Assert.Equal(new RouteContext[] { routeContext, routeContext }, routerCallContextList);
Assert.Equal("Alpha Beta", result.View);
}
public void WebBrowserUrlUpgrade()
{
// PTVS 3.0 changed interpreter ID format.
var factory = new PythonProjectFactory(null);
var sp = new MockServiceProvider();
sp.Services[typeof(SVsQueryEditQuerySave).GUID] = null;
sp.Services[typeof(SVsActivityLog).GUID] = new MockActivityLog();
factory.Site = sp;
var upgrade = (IVsProjectUpgradeViaFactory)factory;
foreach (var testCase in new[] {
new { Name = "NoWebBrowserUrl.pyproj", Expected = 1 },
new { Name = "HasWebBrowserUrl.pyproj", Expected = 0 },
})
{
int actual;
Guid factoryGuid;
string newLocation;
var project = TestData.GetPath("TestData\\ProjectUpgrade\\" + testCase.Name);
using (FileUtils.Backup(project)) {
var hr = upgrade.UpgradeProject(
project,
0u, // no backups
null,
out newLocation,
null,
out actual,
out factoryGuid
);
Assert.AreEqual(0, hr, string.Format("Wrong HR for {0}", testCase.Name));
Assert.AreEqual(testCase.Expected, actual, string.Format("Wrong result for {0}", testCase.Name));
Assert.AreEqual(project, newLocation, string.Format("Wrong location for {0}", testCase.Name));
Console.WriteLine(File.ReadAllText(project));
if (testCase.Expected != 0)
{
AssertUtil.Contains(
File.ReadAllText(project),
"<WebBrowserUrl>http://localhost</WebBrowserUrl>"
);
}
Assert.AreEqual(Guid.Empty, factoryGuid);
}
}
}
public void OnBeforeCloseSolutionTest()
{
var serviceProvider = new MockServiceProvider();
SolutionListener target = new SolutionListener(serviceProvider);
bool eventFired = false;
target.BeforeClosingSolution += (sender, args) => { eventFired = true; };
int expected = VSConstants.S_OK;
int actual = target.OnBeforeCloseSolution(null);
Assert.AreEqual(expected, actual);
Assert.IsTrue(eventFired, "Event was not fired");
}
public void TestOptionSaving()
{
using var workspace = TestWorkspace.CreateCSharp("");
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
var optionStore = new OptionStore(workspace.Options, Enumerable.Empty <IOption>());
using var viewModel = new SpacingViewModel(optionStore, serviceProvider);
// Use the first item's preview.
var checkbox = viewModel.Items.OfType <CheckBoxOptionViewModel>().Where(c => c.Option == CSharpFormattingOptions.SpacingAfterMethodDeclarationName).First();
var initial = checkbox.IsChecked;
checkbox.IsChecked = !checkbox.IsChecked;
Assert.NotEqual(optionStore.GetOption(CSharpFormattingOptions.SpacingAfterMethodDeclarationName), initial);
}
public void VsEventsCookieTest()
{
var serviceProvider = new MockServiceProvider();
SolutionListener_Accessor target = new SolutionListener_Accessor(serviceProvider);
uint expected = 0;
uint actual = target.eventsCookie;
Assert.AreEqual(expected, actual, "initial value should be zero");
target.Initialize();
actual = target.eventsCookie;
Assert.IsTrue(expected < actual, "Value after initialize should not be zero.");
}
public async Task TestOptionLoading()
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(""))
{
var optionSet = workspace.Options.WithChangedOption(CSharpFormattingOptions.SpacingAfterMethodDeclarationName, true);
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
using (var viewModel = new SpacingViewModel(optionSet, serviceProvider))
{
// Use the first item's preview.
var checkbox = viewModel.Items.OfType <CheckBoxOptionViewModel>().Where(c => c.Option == CSharpFormattingOptions.SpacingAfterMethodDeclarationName).First();
Assert.True(checkbox.IsChecked);
}
}
}
public async Task TestOptionLoading()
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(""))
{
var optionSet = workspace.Options.WithChangedOption(CSharpFormattingOptions.SpacingAfterMethodDeclarationName, true);
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
using (var viewModel = new SpacingViewModel(optionSet, serviceProvider))
{
// Use the first item's preview.
var checkbox = viewModel.Items.OfType<CheckBoxOptionViewModel>().Where(c => c.Option == CSharpFormattingOptions.SpacingAfterMethodDeclarationName).First();
Assert.True(checkbox.IsChecked);
}
}
}
public void SetUpFixture()
{
editor = new WixDropDownEditor();
// Edit the value.
mockServiceProvider = new MockServiceProvider();
mockWindowsFormsEditorService = new MockWindowsFormsEditorService();
mockServiceProvider.SetServiceToReturn(mockWindowsFormsEditorService);
expectedNewValue = "NewValue";
mockWindowsFormsEditorService.SetNewValue(expectedNewValue);
newValue = editor.EditValue(mockServiceProvider, "Test");
expectedControlType = mockWindowsFormsEditorService.GetDropDownControlTypeUsed();
}
public void InterpreterIdUpgrade()
{
// PTVS 3.0 changed interpreter ID format.
var factory = new PythonProjectFactory(null);
var sp = new MockServiceProvider();
sp.Services[typeof(SVsQueryEditQuerySave).GUID] = null;
sp.Services[typeof(SVsActivityLog).GUID] = new MockActivityLog();
factory.Site = sp;
var upgrade = (IVsProjectUpgradeViaFactory)factory;
foreach (var testCase in new[] {
new { Name = "CPythonInterpreterId.pyproj", Expected = 1, Id = "Global|PythonCore|2.7|x86" },
new { Name = "CPython35InterpreterId.pyproj", Expected = 1, Id = "Global|PythonCore|3.5-32|x86" },
new { Name = "CPythonx64InterpreterId.pyproj", Expected = 1, Id = "Global|PythonCore|3.5|x64" },
new { Name = "MSBuildInterpreterId.pyproj", Expected = 1, Id = "MSBuild|env|$(MSBuildProjectFullPath)" },
new { Name = "IronPythonInterpreterId.pyproj", Expected = 1, Id = "IronPython|2.7-32" },
})
{
int actual;
Guid factoryGuid;
string newLocation;
var project = TestData.GetPath("TestData\\ProjectUpgrade\\" + testCase.Name);
using (FileUtils.Backup(project)) {
var hr = upgrade.UpgradeProject(
project,
0u, // no backups
null,
out newLocation,
null,
out actual,
out factoryGuid
);
Assert.AreEqual(0, hr, string.Format("Wrong HR for {0}", testCase.Name));
Assert.AreEqual(testCase.Expected, actual, string.Format("Wrong result for {0}", testCase.Name));
Assert.AreEqual(project, newLocation, string.Format("Wrong location for {0}", testCase.Name));
AssertUtil.Contains(
File.ReadAllText(project),
"<InterpreterId>{0}</InterpreterId>".FormatInvariant(testCase.Id)
);
Assert.AreEqual(Guid.Empty, factoryGuid);
}
}
}
public void MscorlibReferenceUpgrade()
{
// IronPython projects typically require mscorlib reference.
// We'll add it if there are any other .NET references
var factory = new PythonProjectFactory(null);
var sp = new MockServiceProvider();
sp.Services[typeof(SVsQueryEditQuerySave).GUID] = null;
sp.Services[typeof(SVsActivityLog).GUID] = new MockActivityLog();
factory.Site = sp;
var upgrade = (IVsProjectUpgradeViaFactory)factory;
foreach (var testCase in new[] {
new { Name = "NoNetReferences.pyproj", Expected = 0 },
new { Name = "HasMscorlib.pyproj", Expected = 0 },
new { Name = "NoMscorlib.pyproj", Expected = 1 },
})
{
var project = TestData.GetPath("TestData\\ProjectUpgrade\\" + testCase.Name);
using (FileUtils.Backup(project))
{
var hr = upgrade.UpgradeProject(
project,
0u, // no backups
null,
out global::System.String newLocation,
null,
out global::System.Int32 actual,
out Guid factoryGuid
);
Assert.AreEqual(0, hr, string.Format("Wrong HR for {0}", testCase.Name));
Assert.AreEqual(testCase.Expected, actual, string.Format("Wrong result for {0}", testCase.Name));
Assert.AreEqual(project, newLocation, string.Format("Wrong location for {0}", testCase.Name));
Console.WriteLine(File.ReadAllText(project));
if (testCase.Expected != 0)
{
AssertUtil.Contains(
File.ReadAllText(project),
"<Reference Include=\"mscorlib"
);
}
Assert.AreEqual(Guid.Empty, factoryGuid);
}
}
}
public static IEnumerable <object[]> AddService_TypeServiceCreatorCallback_TestData()
{
var nullServiceProvider = new MockServiceProvider();
nullServiceProvider.Setup(typeof(IServiceContainer), null);
nullServiceProvider.Setup(typeof(object), null);
nullServiceProvider.Setup(typeof(int), null);
var invalidServiceProvider = new MockServiceProvider();
invalidServiceProvider.Setup(typeof(IServiceContainer), new object());
invalidServiceProvider.Setup(typeof(object), null);
invalidServiceProvider.Setup(typeof(int), null);
var validServiceProvider = new MockServiceProvider();
validServiceProvider.Setup(typeof(IServiceContainer), new ServiceContainer());
validServiceProvider.Setup(typeof(object), null);
validServiceProvider.Setup(typeof(int), null);
var o = new object();
ServiceCreatorCallback callback = (container, serviceType) => "abc";
ServiceCreatorCallback nullCallback = (container, serviceType) => null;
foreach (IServiceProvider parentProvider in new object[] { null, nullServiceProvider, invalidServiceProvider, validServiceProvider })
{
// .NET Core fixes an InvalidCastException bug.
if (PlatformDetection.IsFullFramework && parentProvider == invalidServiceProvider)
{
continue;
}
yield return(new object[] { parentProvider, typeof(object), callback, "abc" });
yield return(new object[] { parentProvider, typeof(string), callback, "abc" });
yield return(new object[] { parentProvider, typeof(int), callback, null });
yield return(new object[] { parentProvider, typeof(object), nullCallback, null });
yield return(new object[] { parentProvider, typeof(int), nullCallback, null });
}
var customServiceProvider = new MockServiceProvider();
customServiceProvider.Setup(typeof(int), o);
yield return(new object[] { customServiceProvider, typeof(int), callback, o });
}
public void UpgradeCheckUserToolsVersion()
{
var factory = new PythonProjectFactory(null);
var sp = new MockServiceProvider();
sp.Services[typeof(SVsQueryEditQuerySave).GUID] = null;
sp.Services[typeof(SVsActivityLog).GUID] = new MockActivityLog();
factory.Site = sp;
var projectFile = TestData.GetPath(Path.Combine("TestData", "ProjectUpgrade", "CorrectToolsVersion.pyproj"));
var upgrade = (IVsProjectUpgradeViaFactory)factory;
foreach (var testCase in new[] {
#if DEV12_OR_LATER
new { Name = "12.0", Expected = 0 },
#else
new { Name = "12.0", Expected = 1 },
#endif
new { Name = "4.0", Expected = 0 }
})
{
int actual;
int hr;
Guid factoryGuid;
uint flags;
var xml = Microsoft.Build.Construction.ProjectRootElement.Create();
xml.ToolsVersion = testCase.Name;
xml.Save(projectFile + ".user");
try {
hr = upgrade.UpgradeProject_CheckOnly(
projectFile,
null,
out actual,
out factoryGuid,
out flags
);
} finally {
File.Delete(projectFile + ".user");
}
Assert.AreEqual(0, hr, string.Format("Wrong HR for ToolsVersion={0}", testCase.Name));
Assert.AreEqual(testCase.Expected, actual, string.Format("Wrong result for ToolsVersion={0}", testCase.Name));
Assert.AreEqual(typeof(PythonProjectFactory).GUID, factoryGuid);
}
}
private static async Task <VsProjectAnalyzer> CreateAnalyzerAsync(PythonVersion version)
{
version.AssertInstalled();
var factory = new MockPythonInterpreterFactory(version.Configuration);
var sp = new MockServiceProvider();
var services = new Microsoft.PythonTools.Editor.PythonEditorServices(sp);
var interpreters = new MockInterpreterOptionsService();
interpreters.AddProvider(new MockPythonInterpreterFactoryProvider("Test Provider", factory));
services.InterpreterRegistryService = interpreters;
services.InterpreterOptionsService = interpreters;
return(await VsProjectAnalyzer.CreateForTestsAsync(
services,
factory
));
}
public void RetrieveAllEmployeeMetricsFail()
{
List <EmployeeMetrics> dbRetVal = new List <EmployeeMetrics>();
MockServiceProvider serviceProvider = new MockServiceProvider()
.AddMockDBConnection();
serviceProvider.MockDBConnection
.Setup(_ => _.ExecuteQuery <EmployeeMetrics>(QueryGenerator.GetEmployeeMetricsHeader() + QueryGenerator.WhereRole("Developer")))
.Returns(dbRetVal);
EmployeeService employeeService = new EmployeeService(serviceProvider.Build());
var response = employeeService.RetrieveAllEmployeeMetrics();
Assert.Null(response);
}
public void TestArtifactIsGenerated()
{
MockServiceProvider serviceProvider = new MockServiceProvider();
MockVSHierarchy root = new MockVSHierarchy();
MockVsSolution solution = new MockVsSolution(root);
MockVSHierarchy project = new MockVSHierarchy("Project1.project");
root.AddProject(project);
serviceProvider.AddService(typeof(SVsSolution), solution);
CodeGenerationService target = new CodeGenerationService(serviceProvider);
MyArtifactLink validLink = new MyArtifactLink(project.GUID, "item1.cs");
Assert.IsFalse(target.IsArtifactAlreadyGenerated(validLink));
project.AddChild("item1.cs");
Assert.IsTrue(target.IsArtifactAlreadyGenerated(validLink));
}
public void RetrieveEmployeeInfoNoResults()
{
List <EttEmployee> dbRetVal = new List <EttEmployee>();
MockServiceProvider serviceProvider = new MockServiceProvider()
.AddMockDBConnection();
serviceProvider.MockDBConnection
.Setup(_ => _.ExecuteQuery <EttEmployee>(QueryGenerator.GetEmployeeInfo("*****@*****.**")))
.Returns(dbRetVal);
EmployeeService employeeService = new EmployeeService(serviceProvider.Build());
EttEmployee response = employeeService.RetrieveEmployeeInfo("*****@*****.**");
Assert.Null(response);
}
public void RetrieveEmployeeMetricsNoResults()
{
List <EmployeeMetrics> dbRetVal = new List <EmployeeMetrics>();
MockServiceProvider serviceProvider = new MockServiceProvider()
.AddMockDBConnection();
serviceProvider.MockDBConnection
.Setup(_ => _.ExecuteQuery <EmployeeMetrics>(QueryGenerator.GetEmployeeMetricsHeader() + QueryGenerator.WhereEmail("*****@*****.**")))
.Returns(dbRetVal);
EmployeeService employeeService = new EmployeeService(serviceProvider.Build());
EmployeeResponse response = employeeService.RetrieveEmployeeMetrics("*****@*****.**");
Assert.Null(response);
}
public void DisposeTest()
{
var serviceProvider = new MockServiceProvider();
var mockUpdateSolutionEvents = new Mock <IVsUpdateSolutionEvents>();
UpdateSolutionListener_Accessor target = new UpdateSolutionListener_Accessor(serviceProvider);
uint cookie = 0;
((IVsSolutionBuildManager)serviceProvider.GetService(typeof(SVsSolutionBuildManager))).AdviseUpdateSolutionEvents(mockUpdateSolutionEvents.Instance as IVsUpdateSolutionEvents, out cookie);
Debug.Assert(cookie == 1);
bool disposing = true;
target.eventsCookie = cookie;
target.Dispose(disposing);
}
public void ExtensionProviderContainerConverterConvertToExtensionProvider()
{
MockExtensionProvider provider = new MockExtensionProvider();
MockServiceProvider mockServiceProvider = new MockServiceProvider();
MockServiceProviderService mockService = new MockServiceProviderService();
mockServiceProvider.AddService(typeof(IExtensionProviderService), mockService);
ExtensionProviderConverter converter = new ExtensionProviderConverter(mockServiceProvider);
MockExtensionProvider provider1 = converter.ConvertFrom(provider.ToString()) as MockExtensionProvider;
Assert.AreEqual(provider.Id, provider1.Id, "Not Equal");
Assert.AreEqual(provider.Description, provider1.Description, "Not Equal");
Assert.AreEqual(provider.Name, provider1.Name, "Not Equal");
}
public void DisposeTest()
{
var serviceProvider = new MockServiceProvider();
var mockUpdateSolutionEvents = new Mock <IVsUpdateSolutionEvents>(MockBehavior.Strict);
UpdateSolutionListener target = new UpdateSolutionListener(serviceProvider);
uint cookie = 0;
((IVsSolutionBuildManager)serviceProvider.GetService(typeof(SVsSolutionBuildManager))).AdviseUpdateSolutionEvents(mockUpdateSolutionEvents.Object, out cookie);
Debug.Assert(cookie == 1);
target.GetType()
.GetField("eventsCookie", BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(target, cookie);
target.Dispose();
}
public void EditValueWithNoFormsServiceThrows()
{
MockVSHierarchy root = new MockVSHierarchy();
MockVsSolution solution = new MockVsSolution(root);
MockServiceProvider serviceProvider = new MockServiceProvider();
serviceProvider.AddService(typeof(IVsSolution), solution);
MockTypeDescriptorContext context = new MockTypeDescriptorContext(serviceProvider);
string value = "Project1.txt";
MockVSHierarchy project = new MockVSHierarchy(value);
root.AddProject(project);
SolutionPickerEditor target = new SolutionPickerEditor();
target.EditValue(serviceProvider, null);
}
public void PythonTargetsProjectUpgrade()
{
var factory = new PythonProjectFactory(null);
var sp = new MockServiceProvider();
sp.Services[typeof(SVsQueryEditQuerySave).GUID] = null;
sp.Services[typeof(SVsActivityLog).GUID] = new MockActivityLog();
factory.Site = sp;
var upgrade = (IVsProjectUpgradeViaFactory)factory;
var project = TestData.GetPath("TestData\\ProjectUpgrade\\OldPythonTargets.pyproj");
using (FileUtils.Backup(project)) {
int actual;
Guid factoryGuid;
string newLocation;
var hr = upgrade.UpgradeProject(
project,
0u, // no backups
null,
out newLocation,
null,
out actual,
out factoryGuid
);
Assert.AreEqual(0, hr, string.Format("Wrong HR for OldPythonTargets.pyproj"));
Assert.AreEqual(1, actual, string.Format("Wrong result for OldPythonTargets.pyproj"));
Assert.AreEqual(project, newLocation, string.Format("Wrong location for OldPythonTargets.pyproj"));
var text = File.ReadAllText(project);
Assert.IsFalse(
text.Contains("<PtvsTargetsFile>"),
string.Format("Upgraded OldPythonTargets.pyproj should not define $(PtvsTargetsFile)")
);
Assert.IsTrue(
text.Contains("<Import Project=\"" + PythonProjectFactory.PtvsTargets + "\""),
string.Format("Upgraded OldPythonTargets.pyproj should import the Python targets directly")
);
Assert.AreEqual(
1, text.FindIndexesOf(PythonProjectFactory.PtvsTargets).Count(),
"Expected only one import of Python targets file"
);
Assert.AreEqual(Guid.Empty, factoryGuid);
}
}
public void SetUpFixture()
{
editor = new GuidEditor();
// Edit the guid value.
mockServiceProvider = new MockServiceProvider();
mockWindowsFormsEditorService = new MockWindowsFormsEditorService();
mockServiceProvider.SetServiceToReturn(mockWindowsFormsEditorService);
expectedNewGuid = Guid.NewGuid().ToString().ToUpperInvariant();
mockWindowsFormsEditorService.SetNewValue(expectedNewGuid);
Guid guid = Guid.NewGuid();
newValue = editor.EditValue(mockServiceProvider, guid.ToString().ToUpperInvariant());
expectedGuidControlType = mockWindowsFormsEditorService.GetDropDownControlTypeUsed();
}
public void TestOptionLoading()
{
using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromFile(""))
{
var optionService = workspace.GetService<IOptionService>();
var optionSet = optionService.GetOptions();
optionSet = optionSet.WithChangedOption(CSharpFormattingOptions.SpacingAfterMethodDeclarationName, true);
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
using (var viewModel = new SpacingViewModel(optionSet, serviceProvider))
{
// Use the first item's preview.
var checkbox = viewModel.Items.OfType<CheckBoxOptionViewModel>().Where(c => c.Option == CSharpFormattingOptions.SpacingAfterMethodDeclarationName).First();
Assert.True(checkbox.IsChecked);
}
}
}
public async Task TestCheckBox()
{
using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromFileAsync(""))
{
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
using (var viewModel = new SpacingViewModel(workspace.Options, serviceProvider))
{
// Use the first item's preview.
var checkbox = viewModel.Items.OfType<CheckBoxOptionViewModel>().First();
viewModel.SetOptionAndUpdatePreview(checkbox.IsChecked, checkbox.Option, checkbox.GetPreview());
// Get a checkbox and toggle it
var originalPreview = GetText(viewModel);
checkbox.IsChecked = !checkbox.IsChecked;
var modifiedPreview = GetText(viewModel);
Assert.NotEqual(modifiedPreview, originalPreview);
// Switch it back
checkbox.IsChecked = !checkbox.IsChecked;
Assert.Equal(originalPreview, viewModel.TextViewHost.TextView.TextBuffer.CurrentSnapshot.GetText().ToString());
}
}
}
public async Task TestFeatureBasedSaving()
{
using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromFileAsync(""))
{
// Set an option for an unrelated feature
var optionService = workspace.GetService<IOptionService>();
var optionSet = optionService.GetOptions();
var expectedValue = !CSharpFormattingOptions.NewLineForCatch.DefaultValue;
optionSet = optionSet.WithChangedOption(CSharpFormattingOptions.NewLineForCatch, expectedValue);
optionService.SetOptions(optionSet);
// Save the options
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
using (var viewModel = new SpacingViewModel(workspace.Options, serviceProvider))
{
var changedOptions = optionService.GetOptions();
Assert.Equal(changedOptions.GetOption(CSharpFormattingOptions.NewLineForCatch), expectedValue);
}
}
}
public async Task TestOptionSaving()
{
using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromFileAsync(""))
{
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
using (var viewModel = new SpacingViewModel(workspace.Options, serviceProvider))
{
// Use the first item's preview.
var checkbox = viewModel.Items.OfType<CheckBoxOptionViewModel>().Where(c => c.Option == CSharpFormattingOptions.SpacingAfterMethodDeclarationName).First();
var initial = checkbox.IsChecked;
checkbox.IsChecked = !checkbox.IsChecked;
var optionService = workspace.GetService<IOptionService>();
var optionSet = optionService.GetOptions();
var changedOptions = viewModel.ApplyChangedOptions(optionSet);
Assert.NotEqual(changedOptions.GetOption(CSharpFormattingOptions.SpacingAfterMethodDeclarationName), initial);
}
}
}
