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);
}
}
}
