public void SharedSourceFiles_Methods() { string projectPath = null; string outputPath = null; TestHelper.GetProjectPaths("SFT", out projectPath, out outputPath); string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); List <string> sourceFiles = CodeGenHelper.ClientClassLibSourceFiles(clientProjectPath); ConsoleLogger logger = new ConsoleLogger(); FilenameMap filenameMap = new FilenameMap(); using (SourceFileLocationService locationService = new SourceFileLocationService(new[] { new PdbSourceFileProviderFactory(/*symbolSearchPath*/ null, logger) }, filenameMap)) { SharedSourceFiles ssf = new SharedSourceFiles(locationService, filenameMap, sourceFiles); int[] fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateMethodKey(typeof(TestValidator).GetMethod("IsValid"))); Assert.IsNotNull(fileIds, "Expected TestValidator.IsValid to have non-null file ID's because it is shared"); Assert.AreEqual(1, fileIds.Length, "Expected TestValidator.IsValid to be found in exactly one file"); Assert.IsTrue(filenameMap[fileIds[0]].Contains("TestValidator.linked.cs"), "Expected TestValidator.IsValid to be in TestValidator.linked.cs"); fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateMethodKey(typeof(TestEntity).GetMethod("ServerAndClientMethod"))); Assert.IsNotNull(fileIds, "Expected TestEntity.ServerAndClientMethod to have non-null file ID's because it is shared"); Assert.AreEqual(1, fileIds.Length, "Expected TestEntity.ServerAndClientMethod to be found in exactly one file"); Assert.IsTrue(filenameMap[fileIds[0]].Contains("TestEntity.linked.cs"), "Expected TestEntity.ServerAndClientMethod to be in TestEntity.linked.cs"); fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateMethodKey(typeof(TestEntity).GetMethod("ServerMethod"))); Assert.IsNull(fileIds, "Expected TestEntity.ServerMethod to have null file ids"); fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateMethodKey(typeof(TestValidatorServer).GetMethod("IsValid"))); Assert.IsNull(fileIds, "Expected TestValidatorServer.IsValid to have null file ids"); } }
public void SharedCodeService_Types() { string projectPath, outputPath; TestHelper.GetProjectPaths("STS1", out projectPath, out outputPath); var clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); var logger = new ConsoleLogger(); using (var scs = CodeGenHelper.CreateSharedCodeService(clientProjectPath, logger)) { // TestEntity is shared because it is linked CodeMemberShareKind shareKind = scs.GetTypeShareKind(typeof(TestEntity).AssemblyQualifiedName); Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestEntity type to be shared by reference"); // TestValidator is shared because it is linked shareKind = scs.GetTypeShareKind(typeof(TestValidator).AssemblyQualifiedName); Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestValidator type to be shared by reference"); // SharedClass is shared because it is linked shareKind = scs.GetTypeShareKind(typeof(SharedClass).AssemblyQualifiedName); Assert.IsTrue(shareKind == CodeMemberShareKind.SharedBySource, "Expected SharedClass type to be shared in source"); // TestValidatorServer exists only on the server and is not shared shareKind = scs.GetTypeShareKind(typeof(TestValidatorServer).AssemblyQualifiedName); Assert.IsTrue(shareKind == CodeMemberShareKind.NotShared, "Expected TestValidatorServer type not to be shared"); // CodelessType exists on both server and client, but lacks all user code necessary // to determine whether it is shared. Because it compiles into both projects, it should // be considered shared by finding the type in both assemblies shareKind = scs.GetTypeShareKind(typeof(CodelessType).AssemblyQualifiedName); Assert.IsTrue(shareKind == CodeMemberShareKind.SharedByReference, "Expected CodelessType type to be shared in assembly"); } }
public void SharedSourceFiles_Types() { string projectPath = null; string outputPath = null; TestHelper.GetProjectPaths("SFT", out projectPath, out outputPath); string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); List <string> sourceFiles = CodeGenHelper.ClientClassLibSourceFiles(clientProjectPath); ConsoleLogger logger = new ConsoleLogger(); FilenameMap filenameMap = new FilenameMap(); using (SourceFileLocationService locationService = new SourceFileLocationService(new[] { new PdbSourceFileProviderFactory(/*symbolSearchPath*/ null, logger) }, filenameMap)) { SharedSourceFiles ssf = new SharedSourceFiles(locationService, filenameMap, sourceFiles); int[] fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateTypeKey(typeof(TestEntity))); Assert.IsNotNull(fileIds, "Expected TestEntity to have non-null file ID's because it is shared"); Assert.AreEqual(2, fileIds.Length, "Expected TestEntity to be found in exactly 2 files"); foreach (int i in fileIds) { string file = filenameMap[i]; Assert.IsTrue(file.Contains("TestEntity.linked.cs") || file.Contains("TestEntity.reverse.linked.cs"), "Expected exactly these 2 files to be shared"); } fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateTypeKey(typeof(TestValidator))); Assert.IsNotNull(fileIds, "Expected TestValidator to have non-null file ID's because it is shared"); Assert.AreEqual(1, fileIds.Length, "Expected TestValidator to be found in exactly one file"); Assert.IsTrue(filenameMap[fileIds[0]].Contains("TestValidator.linked.cs"), "expected this to be the sole shared file for TestValidator"); fileIds = ssf.GetSharedFileIds(CodeMemberKey.CreateTypeKey(typeof(TestValidatorServer))); Assert.IsNull(fileIds, "Expected TestValidatorServer to have no shared file ids"); } }
public void SharedCodeService_Methods() { string projectPath, outputPath; TestHelper.GetProjectPaths("STS4", out projectPath, out outputPath); var clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); var logger = new ConsoleLogger(); using (var scs = CodeGenHelper.CreateSharedCodeService(clientProjectPath, logger)) { CodeMemberShareKind shareKind = scs.GetMethodShareKind(typeof(TestValidator).AssemblyQualifiedName, "IsValid", new string[] { typeof(TestEntity).AssemblyQualifiedName, typeof(ValidationContext).AssemblyQualifiedName }); Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestValidator.IsValid to be shared by reference"); shareKind = scs.GetMethodShareKind(typeof(TestEntity).AssemblyQualifiedName, "ServerAndClientMethod", new string[0]); Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestValidator.ServerAndClientMethod to be shared by reference"); shareKind = scs.GetMethodShareKind(typeof(TestEntity).AssemblyQualifiedName, "ServerMethod", new string[0]); Assert.AreEqual(CodeMemberShareKind.NotShared, shareKind, "Expected TestValidator.ServerMethod not to be shared"); shareKind = scs.GetMethodShareKind(typeof(TestValidatorServer).AssemblyQualifiedName, "IsValid", new string[] { typeof(TestEntity).AssemblyQualifiedName, typeof(ValidationContext).AssemblyQualifiedName }); Assert.AreEqual(CodeMemberShareKind.NotShared, shareKind, "Expected TestValidator.IsValid not to be shared"); TestHelper.AssertNoErrorsOrWarnings(logger); } }
/// <summary> /// Creates a new CreateClientFilesTask instance to use to generate code /// </summary> /// <param name="relativeTestDir"></param> /// <param name="includeClientOutputAssembly">if <c>true</c> include clients own output assembly in analysis</param> /// <returns>A new task instance that can be invoked to do code gen</returns> public static CreateClientFilesTask CreateClientFilesTaskInstance(string relativeTestDir, bool includeClientOutputAssembly) { string projectPath, outputPath; TestHelper.GetProjectPaths(relativeTestDir, out projectPath, out outputPath); Assert.IsTrue(File.Exists(projectPath), "Could not locate " + projectPath + " necessary for test."); string serverProjectPath = ServerClassLibProjectPath(projectPath); string clientProjectPath = ClientClassLibProjectPath(projectPath); return(CreateClientFilesTaskInstance(serverProjectPath, clientProjectPath, includeClientOutputAssembly)); }
/// <summary> /// Creates a new CreateClientFilesTask instance to use to generate code /// using the TestWap project. /// </summary> /// <param name="relativeTestDir"></param> /// <returns>A new task instance that can be invoked to do code gen</returns> public static CreateClientFilesTask CreateClientFilesTaskInstanceForWAP(string relativeTestDir) { var deploymentDir = Path.GetDirectoryName(typeof(CodeGenHelper).Assembly.Location); string projectPath, outputPath; TestHelper.GetProjectPaths(relativeTestDir, out projectPath, out outputPath); Assert.IsTrue(File.Exists(projectPath), "Could not locate " + projectPath + " necessary for test."); string serverProjectPath = ServerWapProjectPath(projectPath); string clientProjectPath = ClientClassLibProjectPath(projectPath); return(CodeGenHelper.CreateClientFilesTaskInstance(serverProjectPath, clientProjectPath, false)); }
/// <summary> /// Creates a new CreateClientFilesTask instance to use to generate code /// </summary> /// <param name="relativeTestDir"></param> /// <param name="includeClientOutputAssembly">if <c>true</c> include clients own output assembly in analysis</param> /// <returns>A new task instance that can be invoked to do code gen</returns> public static CreateClientFilesTask CreateClientFilesTaskInstance_CopyClientProjectToOutput(string relativeTestDir, bool includeClientOutputAssembly) { string deploymentDir = Path.GetDirectoryName(typeof(CodeGenHelper).Assembly.Location); string projectPath = null; string outputPath = null; TestHelper.GetProjectPaths(relativeTestDir, out projectPath, out outputPath); Assert.IsTrue(File.Exists(projectPath), "Could not locate " + projectPath + " necessary for test."); string serverProjectPath = CodeGenHelper.ServerClassLibProjectPath(projectPath); string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); return(CodeGenHelper.CreateClientFilesTaskInstance_CopyClientProjectToOutput(serverProjectPath, clientProjectPath, includeClientOutputAssembly)); }
public void SharedAssemblies_Matches_MsCorLib() { Type[] sharedTypes = new Type[] { typeof(Int32), typeof(string), typeof(Decimal), }; Type[] nonSharedTypes = new Type[] { typeof(SerializableAttribute), typeof(System.Xml.Linq.XElement) }; MethodBase[] sharedMethods = new MethodBase[] { typeof(string).GetMethod("CopyTo"), }; string projectPath, outputPath; TestHelper.GetProjectPaths("SAT", out projectPath, out outputPath); string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); List<string> assemblies = CodeGenHelper.ClientClassLibReferences(clientProjectPath, true); var logger = new ConsoleLogger(); var sa = new SharedAssemblies(assemblies, Enumerable.Empty<string>(), logger); foreach (Type t in sharedTypes) { Type sharedType = sa.GetSharedType(t.AssemblyQualifiedName); Assert.IsNotNull(sharedType, "Expected type " + t.Name + " to be considered shared."); } foreach (MethodBase m in sharedMethods) { string[] parameterTypes = m.GetParameters().Select<ParameterInfo, string>(p => p.ParameterType.AssemblyQualifiedName).ToArray(); MethodBase sharedMethod = sa.GetSharedMethod(m.DeclaringType.AssemblyQualifiedName, m.Name, parameterTypes); Assert.IsNotNull(sharedMethod, "Expected method " + m.DeclaringType.Name + "." + m.Name + " to be considered shared."); } foreach (Type t in nonSharedTypes) { Type sType = sa.GetSharedType(t.AssemblyQualifiedName); Assert.IsNull(sType, "Expected type " + t.Name + " to be considered *not* shared."); } }
public void SharedCodeService_Properties() { string projectPath, outputPath; TestHelper.GetProjectPaths("STS2", out projectPath, out outputPath); var clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); var logger = new ConsoleLogger(); using (var scs = CodeGenHelper.CreateSharedCodeService(clientProjectPath, logger)) { CodeMemberShareKind shareKind = scs.GetPropertyShareKind(typeof(TestEntity).AssemblyQualifiedName, "ServerAndClientValue"); Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestEntity.ServerAndClientValue property to be shared by reference."); shareKind = scs.GetPropertyShareKind(typeof(TestEntity).AssemblyQualifiedName, "TheValue"); Assert.AreEqual(CodeMemberShareKind.NotShared, shareKind, "Expected TestEntity.TheValue property not to be shared in source."); } }
public void SharedCodeService_Ctors() { string projectPath = null; string outputPath = null; TestHelper.GetProjectPaths("STS5", out projectPath, out outputPath); string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); ConsoleLogger logger = new ConsoleLogger(); using (SharedCodeService sts = CodeGenHelper.CreateSharedCodeService(clientProjectPath, logger)) { ConstructorInfo ctor = typeof(TestValidator).GetConstructor(new Type[] { typeof(string) }); Assert.IsNotNull("Failed to find string ctor on TestValidator"); CodeMemberShareKind shareKind = sts.GetMethodShareKind(typeof(TestValidator).AssemblyQualifiedName, ctor.Name, new string[] { typeof(string).AssemblyQualifiedName }); Assert.AreEqual(CodeMemberShareKind.SharedByReference, shareKind, "Expected TestValidator ctor to be shared by reference"); TestHelper.AssertNoErrorsOrWarnings(logger); } }
public void PdbReader_Finds_Types_Files() { string projectPath = null; string outputPath = null; TestHelper.GetProjectPaths("PDB", out projectPath, out outputPath); string serverProjectPath = CodeGenHelper.ServerClassLibProjectPath(projectPath); string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); ConsoleLogger logger = new ConsoleLogger(); FilenameMap filenameMap = new FilenameMap(); using (SourceFileLocationService locationService = new SourceFileLocationService(new[] { new PdbSourceFileProviderFactory(/*symbolSearchPath*/ null, logger) }, filenameMap)) { List <string> files = new List <string>(locationService.GetFilesForType(typeof(TestEntity))); Assert.AreEqual(4, files.Count); CodeGenHelper.AssertContainsFiles(files, serverProjectPath, new string[] { "TestEntity.cs", "TestEntity.shared.cs", "TestEntity.linked.cs" }); CodeGenHelper.AssertContainsFiles(files, clientProjectPath, new string[] { "TestEntity.reverse.linked.cs" }); } }
/// <summary> /// Extract the list of assemblies both generated and referenced by client. /// Not coincidently, this list is what a client project needs to reference. /// </summary> /// <returns></returns> public static List <string> GetClientAssemblies(string relativeTestDir) { var assemblies = new List <string>(); string projectPath, outputPath; // output path for current project, used to infer output path of test project TestHelper.GetProjectPaths(relativeTestDir, out projectPath, out outputPath); // Our current project's folder var projectDir = Path.GetDirectoryName(projectPath); // Folder of project we want to build var testProjectDir = Path.GetFullPath(Path.Combine(projectDir, @"..\..\Luma.SimpleEntity.Client")); var testProjectFile = Path.Combine(testProjectDir, @"Luma.SimpleEntity.Client.csproj"); Assert.IsTrue(File.Exists(testProjectFile), "This test could not find its required project at " + testProjectFile); // Retrieve all the assembly references from the test project (follows project-to-project references too) MsBuildHelper.GetReferenceAssemblies(testProjectFile, assemblies); var outputAssembly = MsBuildHelper.GetOutputAssembly(testProjectFile); if (!string.IsNullOrEmpty(outputAssembly)) { assemblies.Add(outputAssembly); } var frameworkDirectory = CodeGenHelper.GetRuntimeDirectory(); var frameworkAssemblies = Directory.EnumerateFiles(frameworkDirectory, "*.dll"); foreach (var frameworkAssembly in frameworkAssemblies) { if (!assemblies.Contains(frameworkAssembly)) { assemblies.Add(frameworkAssembly); } } return(assemblies); }
public void SharedAssemblies_Methods() { string projectPath, outputPath; TestHelper.GetProjectPaths("SAT", out projectPath, out outputPath); var clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); var assemblies = CodeGenHelper.ClientClassLibReferences(clientProjectPath, true); var logger = new ConsoleLogger(); var sa = new SharedAssemblies(assemblies, Enumerable.Empty<string>(), logger); var sharedMethod = sa.GetSharedMethod(typeof(TestValidator).AssemblyQualifiedName, "IsValid", new[] { typeof(TestEntity).AssemblyQualifiedName, typeof(ValidationContext).AssemblyQualifiedName }); Assert.IsNotNull(sharedMethod, "Expected TestValidator.IsValid to be shared"); Assert.IsTrue(sharedMethod.DeclaringType.Assembly.Location.Contains("ClientClassLib"), "Expected to find method in client class lib"); sharedMethod = sa.GetSharedMethod(typeof(TestEntity).AssemblyQualifiedName, "ServerAndClientMethod", new string[0]); Assert.IsNotNull(sharedMethod, "Expected TestEntity.ServerAndClientMethod to be shared"); Assert.IsTrue(sharedMethod.DeclaringType.Assembly.Location.Contains("ClientClassLib"), "Expected to find method in client class lib"); sharedMethod = sa.GetSharedMethod(typeof(TestValidator).AssemblyQualifiedName, "ServertMethod", new string[0]); Assert.IsNull(sharedMethod, "Expected TestValidator.ServerMethod not to be shared"); TestHelper.AssertNoErrorsOrWarnings(logger); }
public void SharedAssemblies_Types() { string projectPath = null; string outputPath = null; TestHelper.GetProjectPaths("SAT", out projectPath, out outputPath); string clientProjectPath = CodeGenHelper.ClientClassLibProjectPath(projectPath); List<string> assemblies = CodeGenHelper.ClientClassLibReferences(clientProjectPath, true); var logger = new ConsoleLogger(); var sa = new SharedAssemblies(assemblies, Enumerable.Empty<string>(), logger); Type sharedType = sa.GetSharedType(typeof(TestEntity).AssemblyQualifiedName); Assert.IsNotNull(sharedType, "Expected TestEntity type to be shared"); Assert.IsTrue(sharedType.Assembly.Location.Contains("ClientClassLib"), "Expected to find type in client class lib"); sharedType = sa.GetSharedType(typeof(TestValidator).AssemblyQualifiedName); Assert.IsNotNull(sharedType, "Expected TestValidator type to be shared"); Assert.IsTrue(sharedType.Assembly.Location.Contains("ClientClassLib"), "Expected to find type in client class lib"); sharedType = sa.GetSharedType(typeof(TestValidatorServer).AssemblyQualifiedName); Assert.IsNull(sharedType, "Expected TestValidatorServer type not to be shared"); TestHelper.AssertNoErrorsOrWarnings(logger); }
public void PdbReader_Finds_Method_Files() { string projectPath = null; string outputPath = null; TestHelper.GetProjectPaths("PDB", out projectPath, out outputPath); using (ISourceFileProvider pdbReader = new PdbSourceFileProviderFactory(/*symbolSearchPath*/ null, /*logger*/ null).CreateProvider()) { string serverProjectPath = CodeGenHelper.ServerClassLibProjectPath(projectPath); Type testEntityType = typeof(TestEntity); PropertyInfo pInfo = testEntityType.GetProperty("TheKey"); Assert.IsNotNull(pInfo); // Must find TheKey in only TestEntity.cs -- it is readonly and has no setter string actualFile = pdbReader.GetFileForMember(pInfo.GetGetMethod()); string expectedFile = Path.Combine(Path.GetDirectoryName(serverProjectPath), "TestEntity.cs"); Assert.AreEqual(expectedFile.ToUpperInvariant(), actualFile.ToUpperInvariant()); // Must find TheValue in only TestEntity.cs pInfo = testEntityType.GetProperty("TheValue"); actualFile = pdbReader.GetFileForMember(pInfo.GetGetMethod()); expectedFile = Path.Combine(Path.GetDirectoryName(serverProjectPath), "TestEntity.cs"); // Must find TheSharedValue in only TestEntity.shared.cs -- validates we locate shared files pInfo = testEntityType.GetProperty("TheSharedValue"); actualFile = pdbReader.GetFileForMember(pInfo.GetGetMethod()); expectedFile = Path.Combine(Path.GetDirectoryName(serverProjectPath), "TestEntity.shared.cs"); // Must find ServerAndClientValue in only TestEntity.linked.cs -- validates we locate linked files pInfo = testEntityType.GetProperty("ServerAndClientValue"); actualFile = pdbReader.GetFileForMember(pInfo.GetGetMethod()); expectedFile = Path.Combine(Path.GetDirectoryName(serverProjectPath), "TestEntity.linked.cs"); } }
public void ProjectSourceFileCache_Loads_Real_Project() { string projectPath = null; string outputPath = null; TestHelper.GetProjectPaths("SSFC", out projectPath, out outputPath); string serverProjectPath = CodeGenHelper.ServerClassLibProjectPath(projectPath); string breadCrumbFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".txt"); ConsoleLogger logger = new ConsoleLogger(); using (ProjectFileReader projectFileReader = new ProjectFileReader(logger)) { try { // Instantiate the cache. ProjectSourceFileCache cache = new ProjectSourceFileCache(serverProjectPath, breadCrumbFile, logger, projectFileReader); // Initially, it will not have loaded anything Assert.AreEqual(0, cache.SourceFilesByProject.Count); // ------------------------------------------------------------- // Validate cache is loaded correctly from .csproj files // ------------------------------------------------------------- this.ValidateProjectSourceFileCache(cache, projectPath); // Ask to write out the breadcrumb file Assert.IsFalse(File.Exists(breadCrumbFile)); bool success = cache.SaveCacheToFile(); Assert.IsTrue(success); Assert.IsTrue(File.Exists(breadCrumbFile)); // Clear the cache and force it to read from breadcrumb cache.SourceFilesByProject.Clear(); success = cache.LoadCacheFromFile(); Assert.IsTrue(success, "Failed to load from breadCrumb file"); Assert.IsTrue(cache.IsFileCacheCurrent, "Loading from file should have marked cache as current with file."); // ------------------------------------------------------------- // Validate cache is loaded correctly from breadcrumb file // ------------------------------------------------------------- this.ValidateProjectSourceFileCache(cache, projectPath); // Now mark the breadcrumb file as if it had been written before the ServerClassLib project cache.SourceFilesByProject.Clear(); DateTime serverLastWriteTime = File.GetLastWriteTime(serverProjectPath); DateTime beforeServerLastWriteTime = new DateTime(serverLastWriteTime.Ticks - 1000); File.SetLastWriteTime(breadCrumbFile, beforeServerLastWriteTime); // ------------------------------------------------------------- // Validate cache is *not* loaded if timestamp is before project's // ------------------------------------------------------------- success = cache.LoadCacheFromFile(); Assert.IsFalse(success, "Expected breadCrumbFile time stamp to be caught and reject load"); Assert.IsFalse(cache.IsFileCacheCurrent, "Failed load from file should have marked cache as *not* current with file."); // Cache should still be empty Assert.AreEqual(0, cache.SourceFilesByProject.Count); // ------------------------------------------------------------- // Validate cache loaded in presence of out-of-date breadcrumb // file loads correctly // ------------------------------------------------------------- this.ValidateProjectSourceFileCache(cache, projectPath); Assert.IsFalse(cache.IsFileCacheCurrent, "Loading from project should have marked cache as *not* current with file."); } finally { if (File.Exists(breadCrumbFile)) { File.Delete(breadCrumbFile); } } } }