public void TestGetSnippet() { CodeSnippet codeSnippet = new CodeSnippet { MockInitCode = "hello" }; this.mockTranslator.Setup(x => x.Translate(It.IsAny<string>())).Returns(codeSnippet); CodeSnippet codeSnippetReturn = this.service.GetSnippet("path"); Assert.IsTrue(codeSnippetReturn.MockInitCode == codeSnippet.MockInitCode); }
/// <summary> /// Injects the mocking details. /// </summary> /// <param name="codeSnippet">The code snippet.</param> public void InjectMockingDetails(CodeSnippet codeSnippet) { TraceService.WriteLine("MoqMockingService::InjectMockingDetails"); codeSnippet.MockingVariableDeclaration = TestingConstants.Moq.MockingVariableDeclaration; codeSnippet.MockConstructorCode = TestingConstants.Moq.MockConstructorCode; codeSnippet.MockInitCode = TestingConstants.Moq.MockInitCode; }
/// <summary> /// Applies the global variables. /// </summary> /// <param name="visualStudioService">The visual studio service.</param> /// <param name="codeSnippet">The code snippet.</param> public void ApplyGlobals( IVisualStudioService visualStudioService, CodeSnippet codeSnippet) { TraceService.WriteLine("SnippetService::ApplyGlobals"); bool hasGlobals = visualStudioService.DTEService.SolutionService.HasGlobals; if (hasGlobals) { Dictionary<string, string> dictionary = visualStudioService.DTEService.SolutionService.GetGlobalVariables(); if (dictionary != null) { foreach (KeyValuePair<string, string> keyValuePair in dictionary .Where(keyValuePair => keyValuePair.Value != null)) { codeSnippet.AddReplacementVariable(keyValuePair.Key, keyValuePair.Value); } } } }
public void TestBuildTestingSnippet() { CodeSnippet codeSnippet = new CodeSnippet(); this.mockSettingsService.SetupGet(x => x.UnitTestingAssemblies).Returns("unittestassembly"); this.mockSettingsService.SetupGet(x => x.UnitTestingInitMethod).Returns("initmethod"); this.factory.BuildTestingSnippet(codeSnippet); Assert.IsTrue(codeSnippet.UsingStatements.Count == 2); Assert.IsTrue(codeSnippet.TestInitMethod == "initmethod"); }
/// <summary> /// Injects the mocking details. /// </summary> /// <param name="codeSnippet">The code snippet.</param> public void InjectMockingDetails(CodeSnippet codeSnippet) { TraceService.WriteLine("NSubstituteMockingService::InjectMockingDetails"); codeSnippet.MockInitCode = TestingConstants.NSubstitute.MockInitCode; }
public void TestAddPlugins() { //// arrange List<Plugin> plugins = new List<Plugin> { new Plugin { FileName = "fileName", FriendlyName = "friendlyName", Source = "source" } }; //// core Mock<IProjectService> mockCoreProjectService = new Mock<IProjectService>(); this.mockVisualStudioService.SetupGet(x => x.CoreProjectService).Returns(mockCoreProjectService.Object); Mock<IProjectItemService> mockProjectItemService = new Mock<IProjectItemService>(); mockCoreProjectService.Setup(x => x.GetProjectItem(It.IsAny<string>())) .Returns(mockProjectItemService.Object); Mock<ProjectItem> mockProjectItem = new Mock<ProjectItem>(); mockProjectItemService.SetupGet(x => x.ProjectItem).Returns(mockProjectItem.Object); //// tests Mock<IProjectService> mockTestsProjectService = new Mock<IProjectService>(); this.mockVisualStudioService.SetupGet(x => x.CoreTestsProjectService).Returns(mockTestsProjectService.Object); //// droid Mock<IProjectService> mockDroidProjectService = new Mock<IProjectService>(); this.mockVisualStudioService.SetupGet(x => x.DroidProjectService).Returns(mockDroidProjectService.Object); //// ios Mock<IProjectService> mockiOSProjectService = new Mock<IProjectService>(); this.mockVisualStudioService.SetupGet(x => x.iOSProjectService).Returns(mockiOSProjectService.Object); //// windows phone Mock<IProjectService> mockWindowsPhoneProjectService = new Mock<IProjectService>(); this.mockVisualStudioService.SetupGet(x => x.WindowsPhoneProjectService) .Returns(mockWindowsPhoneProjectService.Object); //// windows store Mock<IProjectService> mockWindowsStoreProjectService = new Mock<IProjectService>(); this.mockVisualStudioService.SetupGet(x => x.WindowsStoreProjectService) .Returns(mockWindowsStoreProjectService.Object); //// wpf Mock<IProjectService> mockWpfProjectService = new Mock<IProjectService>(); this.mockVisualStudioService.SetupGet(x => x.WpfProjectService).Returns(mockWpfProjectService.Object); this.mockFile.FileExists = true; this.mockSettingsService.SetupGet(x => x.UseNugetForPlugins).Returns(true); CodeSnippet codeSnippet = new CodeSnippet { UsingStatements = new List<string>() }; this.mockSnippetsService.Setup(x => x.GetSnippet(It.IsAny<string>())).Returns(codeSnippet); //// act this.service.AddPlugins(this.mockVisualStudioService.Object, plugins, "viewModelName", true); //// assert mockProjectItemService.Verify(x => x.ImplementCodeSnippet(It.IsAny<CodeSnippet>(), It.IsAny<bool>())); }
public void TestGetUnitTestingSnippet() { CodeSnippet codeSnippet = new CodeSnippet { MockInitCode = "hello" }; this.mockTranslator.Setup(x => x.Translate(It.IsAny<string>())).Returns(codeSnippet); SettingsService settingsService = new SettingsService(); this.mockSettingsService.SetupGet(x => x.UnitTestingAssemblies) .Returns(settingsService.UnitTestingAssemblies); this.mockSettingsService.SetupGet(x => x.UnitTestingInitMethod) .Returns(settingsService.UnitTestingInitMethod); CodeSnippet codeSnippetReturn = this.service.GetUnitTestingSnippet("path"); Assert.IsTrue(codeSnippetReturn.MockInitCode == codeSnippet.MockInitCode); Assert.IsTrue(codeSnippetReturn.UsingStatements.Count == 2); Assert.IsTrue(codeSnippetReturn.TestInitMethod == settingsService.UnitTestingInitMethod); }
public void TestApplyGlobals() { Mock<ISolutionService> mockSolutionService = new Mock<ISolutionService>(); mockSolutionService.Setup(x => x.HasGlobals).Returns(true); Dictionary<string, string> dictionary = new Dictionary<string, string> { { "key", "value" } }; mockSolutionService.Setup(x => x.GetGlobalVariables()).Returns(dictionary); Mock<IDTEService> mockDTEService = new Mock<IDTEService>(); mockDTEService.SetupGet(x => x.SolutionService).Returns(mockSolutionService.Object); Mock<IVisualStudioService> mockVisualStudioService = new Mock<IVisualStudioService>(); mockVisualStudioService.SetupGet(x => x.DTEService).Returns(mockDTEService.Object); CodeSnippet codeSnippet = new CodeSnippet(); this.service.ApplyGlobals( mockVisualStudioService.Object, codeSnippet); Assert.IsTrue(codeSnippet.ReplacementVariables.Count == 1); }
/// <summary> /// Applies the code snippet. /// </summary> /// <param name="visualStudioService">The visual studio service.</param> /// <param name="codeSnippet">The code snippet.</param> /// <returns>The messages.</returns> internal IEnumerable<string> ApplyCodeSnippet( IVisualStudioService visualStudioService, CodeSnippet codeSnippet) { TraceService.WriteLine("CodeConfigService::ApplyCodeSnippet"); List<string> messages = new List<string>(); //// find the project IProjectService projectService = visualStudioService.GetProjectServiceBySuffix(codeSnippet.Project); //// find the class IProjectItemService projectItemService = projectService?.GetProjectItem(codeSnippet.Class + ".cs"); //// find the method. CodeFunction codeFunction = projectItemService?.GetFirstClass().GetFunction(codeSnippet.Method); string code = codeFunction?.GetCode(); if (code?.Contains(codeSnippet.Code.Trim()) == false) { codeFunction.InsertCode(codeSnippet.Code, true); string message = string.Format( "Code added to project {0} class {1} method {2}.", projectService.Name, codeSnippet.Class, codeSnippet.Method); messages.Add(message); } return messages; }
/// <summary> /// Creates the unit tests. /// </summary> /// <param name="visualStudioService">The visual studio service.</param> /// <param name="projectService">The project service.</param> /// <param name="codeSnippet">The code snippet.</param> /// <param name="viewModelName">Name of the view model.</param> /// <param name="friendlyName">Name of the friendly.</param> /// <param name="usingStatement">The using statement.</param> /// <returns>The project item service.</returns> public IProjectItemService CreateUnitTests( IVisualStudioService visualStudioService, IProjectService projectService, CodeSnippet codeSnippet, string viewModelName, string friendlyName, string usingStatement) { TraceService.WriteLine("SnippetService::CreateUnitTests viewModelName=" + viewModelName); if (codeSnippet != null) { if (string.IsNullOrEmpty(usingStatement) == false) { if (codeSnippet.UsingStatements == null) { codeSnippet.UsingStatements = new List<string>(); } codeSnippet.UsingStatements.Add(usingStatement); } if (this.settingsService.ReplaceVariablesInSnippets) { this.ApplyGlobals(visualStudioService, codeSnippet); } this.mockingService.InjectMockingDetails(codeSnippet); } string fileName = "Test" + viewModelName; //// are we going to assume that the TestViewModel source file already exists? IProjectItemService projectItemService = projectService.GetProjectItem(fileName); if (projectItemService != null) { if (codeSnippet != null) { projectItemService.ImplementUnitTestingCodeSnippet( codeSnippet, viewModelName, this.settingsService.RemoveDefaultFileHeaders, this.settingsService.RemoveDefaultComments, this.settingsService.FormatFunctionParameters); this.Messages.Add(friendlyName + " test code added to " + fileName + ".cs in project " + projectService.Name + "."); } return projectItemService; } return null; }
/// <summary> /// Injects the mocking details. /// </summary> /// <param name="codeSnippet">The code snippet.</param> public void InjectMockingDetails(CodeSnippet codeSnippet) { TraceService.WriteLine("RhinoMocksMockingService::InjectMockingDetails"); codeSnippet.MockInitCode = TestingConstants.RhinoMocks.MockInitCode; }
public void TestCreateUnitTests() { Mock<IProjectItemService> mockProjectItemService = new Mock<IProjectItemService>(); Mock<IProjectService> mockProjectService = new Mock<IProjectService>(); mockProjectService.Setup(x => x.GetProjectItem(It.IsAny<string>())).Returns(mockProjectItemService.Object); CodeSnippet codeSnippet = new CodeSnippet(); Mock<ISnippetService> mockSnippetService = new Mock<ISnippetService>(); mockSnippetService.Setup(x => x.GetUnitTestingSnippet(It.IsAny<string>())).Returns(codeSnippet); Mock<IVisualStudioService> mockVisualStudioService = new Mock<IVisualStudioService>(); this.service.CreateUnitTests( mockVisualStudioService.Object, mockProjectService.Object, "codeSnippetsPath", "viewModelName", "friendlyName", "usingStatement"); mockProjectItemService.Verify(x => x.ImplementUnitTestingCodeSnippet( It.IsAny<CodeSnippet>(), It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<bool>())); }
/// <summary> /// Builds the testing snippet. /// </summary> /// <param name="codeSnippet">The code snippet.</param> internal void BuildTestingSnippet(CodeSnippet codeSnippet) { TraceService.WriteLine("CodeSnippetFactory::BuildTestingSnippet"); //// we grab thecurrious.core files and add them to the test project. //// doing this way means we don't need them in the xml files string assemblies = this.settingsService.UnitTestingAssemblies; if (string.IsNullOrEmpty(assemblies) == false) { string[] parts = assemblies.Split(','); foreach (string part in parts) { codeSnippet.UsingStatements.Add(part); } } //// adding the specific mocking framework assembly reference. codeSnippet.UsingStatements.Add(this.mockingService.MockingAssemblyReference); //// add in the init method here- doing this way means we dont need it in the xml files codeSnippet.TestInitMethod = this.settingsService.UnitTestingInitMethod; }
/// <summary> /// Applies the global variables. /// </summary> /// <param name="visualStudioService">The visual studio service.</param> /// <param name="codeSnippet">The code snippet.</param> protected void ApplyGlobals( IVisualStudioService visualStudioService, CodeSnippet codeSnippet) { TraceService.WriteLine("BaseCodeService::ApplyGlobals"); Globals globals = visualStudioService.DTE2.Solution.Globals; foreach (string variable in (Array)globals.VariableNames) { string value = globals[variable]; TraceService.WriteLine("BaseCodeService::ApplyGlobals variable=" + variable + " value=" + value); if (value != null) { codeSnippet.AddReplacementVariable(variable, value); } } }