/// <summary>
/// Creates a new CreateOpenRiaClientFilesTask 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 CreateOpenRiaClientFilesTask CreateOpenRiaClientFilesTaskInstance_CopyClientProjectToOutput(string serverProjectPath, string clientProjectPath, bool includeClientOutputAssembly)
{
CreateOpenRiaClientFilesTask task = new CreateOpenRiaClientFilesTask();
MockBuildEngine mockBuildEngine = new MockBuildEngine();
task.BuildEngine = mockBuildEngine;
task.Language = "C#";
task.ServerProjectPath = serverProjectPath;
task.ServerAssemblies = new TaskItem[] { new TaskItem(CodeGenHelper.ServerClassLibOutputAssembly(task.ServerProjectPath)) };
task.ServerReferenceAssemblies = MsBuildHelper.AsTaskItems(CodeGenHelper.ServerClassLibReferences(task.ServerProjectPath)).ToArray();
task.ClientFrameworkPath = CodeGenHelper.GetClientRuntimeDirectory();
// Generate the code to our deployment directory
string tempFolder = CodeGenHelper.GenerateTempFolder();
task.OutputPath = Path.Combine(tempFolder, "FileWrites");
task.GeneratedCodePath = Path.Combine(tempFolder, "Generated_Code");
string clientProjectFileName = Path.GetFileName(clientProjectPath);
string clientProjectDestPath = Path.Combine(tempFolder, clientProjectFileName);
File.Copy(clientProjectPath, clientProjectDestPath);
task.ClientProjectPath = clientProjectDestPath;
task.ClientReferenceAssemblies = MsBuildHelper.AsTaskItems(CodeGenHelper.ClientClassLibReferences(clientProjectPath, includeClientOutputAssembly)).ToArray();
task.ClientSourceFiles = MsBuildHelper.AsTaskItems(CodeGenHelper.ClientClassLibSourceFiles(clientProjectPath)).ToArray();
return(task);
}
/// <summary>
/// Deletes all the files and folders created by the given CreteRiaClientFilesTask
/// </summary>
/// <param name="task"></param>
public static void DeleteTempFolder(CreateOpenRiaClientFilesTask task)
{
if (task != null)
{
string tempFolder = Path.GetDirectoryName(task.OutputPath);
DeleteTempFolder(tempFolder);
}
}
public void SharedTypes_CodeGen_Errors_On_Existing_Generated_Entity()
{
CreateOpenRiaClientFilesTask task = null;
try
{
task = CodeGenHelper.CreateOpenRiaClientFilesTaskInstance("STT", /*includeClientOutputAssembly*/ true);
MockBuildEngine mockBuildEngine = task.BuildEngine as MockBuildEngine;
bool success = task.Execute();
Assert.IsFalse(success, "Expected build to fail");
string entityMsg = string.Format(CultureInfo.CurrentCulture, Resource.ClientCodeGen_EntityTypesCannotBeShared_Reference, "ServerClassLib.TestEntity");
string complexMsg = string.Format(CultureInfo.CurrentCulture, Resource.ClientCodeGen_ComplexTypesCannotBeShared_Reference, "ServerClassLib.TestComplexType");
TestHelper.AssertContainsErrors(mockBuildEngine.ConsoleLogger, entityMsg, complexMsg);
}
finally
{
CodeGenHelper.DeleteTempFolder(task);
}
}
public void CreateOpenRiaClientFilesTask_Validate_UseFullTypeNames_Property()
{
// All these strings should be considered 'false' when parsed in this string property
string[] falseStrings = { Boolean.FalseString, string.Empty, null, "1", "junk" };
CreateOpenRiaClientFilesTask task = new CreateOpenRiaClientFilesTask();
// Default is null which translates to 'false'
Assert.IsNull(task.UseFullTypeNames, "UseFullTypeNames should default to null");
Assert.IsFalse(task.UseFullTypeNamesAsBool, "UseFullTypeNamesAsBool should default to false");
// Setting to "true" is possible and is reflected in bool
task.UseFullTypeNames = Boolean.TrueString;
Assert.AreEqual(Boolean.TrueString, task.UseFullTypeNames);
Assert.IsTrue(task.UseFullTypeNamesAsBool, "UseFullTypeNamesAsBool should be true when string is Boolean.TrueString");
// Try a combination of 'false' strings and verify all yield false bool
foreach (string falseString in falseStrings)
{
task.UseFullTypeNames = falseString;
Assert.AreEqual(falseString, task.UseFullTypeNames);
Assert.IsFalse(task.UseFullTypeNamesAsBool, "UseFullTypeNameAsBool should be false when string is <" + falseString + ">");
}
}
public void CreateOpenRiaClientFilesTask_Validate_GeneratedCodePath_Property()
{
CreateOpenRiaClientFilesTask task = new CreateOpenRiaClientFilesTask();
// Create a dummy folder and project file. They don't have to exist for this test to run
string clientProjectFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
string clientProjectPath = Path.Combine(clientProjectFolder, "MockProj.csproj");
task.ClientProjectPath = clientProjectPath;
// Verify default generated code path is computed
string path = task.GeneratedCodePath;
Assert.IsNotNull(path);
Assert.IsTrue(path.Length > 0);
Assert.AreEqual(RiaClientFilesTask.GeneratedCodeFolderName, Path.GetFileName(path));
Assert.IsTrue(Path.IsPathRooted(path), "Generated code path must be full path");
Assert.AreEqual(Path.GetDirectoryName(task.ClientProjectPath), Path.GetDirectoryName(path), "Generated code path must be relative to project");
// Verify can set to arbitrary relative path that is converted to full path relative to project
task.GeneratedCodePath = "foo";
path = task.GeneratedCodePath;
Assert.IsNotNull(path);
Assert.IsTrue(path.Length > 0);
Assert.AreEqual("foo", Path.GetFileName(path));
Assert.IsTrue(Path.IsPathRooted(path), "Generated code path must be full path");
Assert.AreEqual(Path.GetFullPath(path), path, "Generated code path should have been full path");
Assert.AreEqual(Path.GetDirectoryName(task.ClientProjectPath), Path.GetDirectoryName(path), "Generated code path must be relative to project");
// Verify can set to full path
string fullPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
task.GeneratedCodePath = fullPath;
Assert.AreEqual(fullPath, task.GeneratedCodePath);
Assert.IsFalse(Directory.Exists(fullPath), "Getter should not create folder");
try
{
// Now, use normal helper to create it if it does not exist
bool createdFolder = task.SafeFolderCreate(fullPath);
Assert.IsTrue(createdFolder, "Failed to create folder");
Assert.IsTrue(Directory.Exists(fullPath), "Generated code path should have been generated");
}
finally
{
if (Directory.Exists(fullPath))
{
Directory.Delete(fullPath);
}
}
}
public void SharedTypes_CodeGen_Skips_Shared_Types_And_Properties()
{
CreateOpenRiaClientFilesTask task = null;
string[] expectedOutputFiles = new string[] {
"ServerClassLib.g.cs", // generated
"TestEntity.shared.cs", // via server project
"TestComplexType.shared.cs", // via server project
"ServerClassLib2.shared.cs" // via P2P
};
try
{
task = CodeGenHelper.CreateOpenRiaClientFilesTaskInstance("STT", /*includeClientOutputAssembly*/ false);
MockBuildEngine mockBuildEngine = task.BuildEngine as MockBuildEngine;
// Work Item 199139:
// We're stripping ServerClassLib2 from the reference assemblies since we cannot depend on Visual Studio
// to reliably produce a full set of dependencies. This will force the assembly resolution code to
// search for ServerClassLib2 during codegen.
// Note: Our assembly resolution code is only exercised when running against an installed product. When
// we're running locally, resolution occurs without error.
task.ServerReferenceAssemblies = task.ServerReferenceAssemblies.Where(item => !item.ItemSpec.Contains("ServerClassLib2")).ToArray();
bool success = task.Execute();
if (!success)
{
Assert.Fail("CreateOpenRiaClientFilesTask failed:\r\n" + mockBuildEngine.ConsoleLogger.Errors);
}
ITaskItem[] outputFiles = task.OutputFiles.ToArray();
Assert.AreEqual(expectedOutputFiles.Length, outputFiles.Length);
string generatedFile = CodeGenHelper.GetOutputFile(outputFiles, expectedOutputFiles[0]);
string generatedCode = string.Empty;
using (StreamReader t1 = new StreamReader(generatedFile))
{
generatedCode = t1.ReadToEnd();
}
ConsoleLogger logger = new ConsoleLogger();
logger.LogMessage(generatedCode);
CodeGenHelper.AssertGenerated(generatedCode, "public sealed partial class TestEntity : Entity");
CodeGenHelper.AssertGenerated(generatedCode, "public string TheKey");
CodeGenHelper.AssertGenerated(generatedCode, "public int TheValue");
CodeGenHelper.AssertGenerated(generatedCode, "public sealed partial class TestComplexType : ComplexObject");
CodeGenHelper.AssertGenerated(generatedCode, "public int TheComplexTypeValueProperty");
// This property is in shared code (via link) and should not have been generated
CodeGenHelper.AssertNotGenerated(generatedCode, "public int ServerAndClientValue");
// The automatic property in shared code should not have been generated
CodeGenHelper.AssertNotGenerated(generatedCode, "public string AutomaticProperty");
// The server-only IsValid method should have emitted a comment warning it is not shared
CodeGenHelper.AssertGenerated(generatedCode, "// [CustomValidationAttribute(typeof(ServerClassLib.TestValidatorServer), \"IsValid\")]");
// The TestDomainSharedService already had a matching TestDomainSharedContext DomainContext
// pre-built into the client project. Verify we did *NOT* regenerate a 2nd copy
CodeGenHelper.AssertNotGenerated(generatedCode, "TestDomainShared");
CodeGenHelper.AssertNotGenerated(generatedCode, "TestEntity2");
// This property is in shared code in a p2p referenced assembly and should not have been generated
CodeGenHelper.AssertNotGenerated(generatedCode, "public int SharedProperty_CL2");
// Test that we get an informational message about skipping this shared domain context
string msg = string.Format(CultureInfo.CurrentCulture, Resource.Shared_DomainContext_Skipped, "TestDomainSharedService");
TestHelper.AssertContainsMessages(mockBuildEngine.ConsoleLogger, msg);
}
finally
{
CodeGenHelper.DeleteTempFolder(task);
}
}
public void CleanRiaClientFiles_Deletes_Generated_Files()
{
CreateOpenRiaClientFilesTask task = null;
MockBuildEngine mockBuildEngine;
try
{
// ====================================================
// Test setup -- generate code by calling Create task
// ====================================================
task = CodeGenHelper.CreateOpenRiaClientFilesTaskInstance("CLRCF1", /*includeClientOutputAssembly*/ false);
bool success = task.Execute();
if (!success)
{
mockBuildEngine = task.BuildEngine as MockBuildEngine;
Assert.Fail("CreateOpenRiaClientFilesTask failed:\r\n" + mockBuildEngine.ConsoleLogger.Errors);
}
string generatedCodeOutputFolder = task.GeneratedCodePath;
Assert.IsTrue(Directory.Exists(generatedCodeOutputFolder), "Expected task to have created " + generatedCodeOutputFolder);
string[] files = Directory.GetFiles(generatedCodeOutputFolder);
Assert.AreEqual(3, files.Length, "Code gen should have generated 3 code files");
string generatedFile = Path.Combine(generatedCodeOutputFolder, "ServerClassLib.g.cs");
Assert.IsTrue(File.Exists(generatedFile), "Expected task to have generated " + generatedFile);
string copiedFile = Path.Combine(generatedCodeOutputFolder, "TestEntity.shared.cs");
Assert.IsTrue(File.Exists(copiedFile), "Expected task to have copied " + copiedFile);
copiedFile = Path.Combine(generatedCodeOutputFolder, "TestComplexType.shared.cs");
Assert.IsTrue(File.Exists(copiedFile), "Expected task to have copied " + copiedFile);
string outputFolder = task.OutputPath;
Assert.IsTrue(Directory.Exists(outputFolder), "Expected task to have created " + outputFolder);
files = Directory.GetFiles(outputFolder);
string generatedFiles = string.Empty;
foreach (string file in files)
{
generatedFiles += (file + Environment.NewLine);
}
Assert.AreEqual(5, files.Length, "Code gen should have generated this many ancillary files but instead saw:" + Environment.NewLine + generatedFiles);
string fileList = Path.Combine(outputFolder, "ClientClassLib.OpenRiaFiles.txt");
Assert.IsTrue(File.Exists(fileList), "Expected code gen to have created " + fileList + " but saw:" +
Environment.NewLine + generatedFiles);
string refList = Path.Combine(outputFolder, "ClientClassLib.OpenRiaClientRefs.txt");
Assert.IsTrue(File.Exists(refList), "Expected code gen to have created " + refList + " but saw:" +
Environment.NewLine + generatedFiles);
refList = Path.Combine(outputFolder, "ClientClassLib.OpenRiaServerRefs.txt");
Assert.IsTrue(File.Exists(refList), "Expected code gen to have created " + refList + " but saw:" +
Environment.NewLine + generatedFiles);
string sourceFileList = Path.Combine(outputFolder, "ClientClassLib.OpenRiaSourceFiles.txt");
Assert.IsTrue(File.Exists(sourceFileList), "Expected code gen to have created " + sourceFileList + " but saw:" +
Environment.NewLine + generatedFiles);
string riaLinkList = Path.Combine(outputFolder, "ClientClassLib.OpenRiaLinks.txt");
Assert.IsTrue(File.Exists(riaLinkList), "Expected code gen to have created " + riaLinkList + " but saw:" +
Environment.NewLine + generatedFiles);
// ==========================================
// Main body of test -- the Clean
// ==========================================
// Step 1: instantiate Clean task instance and execute it, giving it same info as the Create task
CleanOpenRiaClientFilesTask cleanTask = new CleanOpenRiaClientFilesTask();
mockBuildEngine = new MockBuildEngine();
cleanTask.BuildEngine = mockBuildEngine;
cleanTask.OutputPath = task.OutputPath;
cleanTask.GeneratedCodePath = task.GeneratedCodePath;
cleanTask.ClientProjectPath = task.ClientProjectPath;
success = cleanTask.Execute();
Assert.IsTrue(success, "Clean task returned false");
// No errors or warnings allowed
TestHelper.AssertNoErrorsOrWarnings(mockBuildEngine.ConsoleLogger);
// Step 2: validate files created above are gone
// TODO, 244509: we no longer remove empty folder
// Assert.IsFalse(Directory.Exists(generatedCodeOutputFolder), "Expected clean to have deleted " + generatedCodeOutputFolder);
Assert.IsFalse(File.Exists(fileList), "Expected clean to have deleted " + fileList);
Assert.IsFalse(File.Exists(refList), "Expected clean to have deleted " + refList);
Assert.IsFalse(File.Exists(sourceFileList), "Expected clean to have deleted " + sourceFileList);
Assert.IsFalse(File.Exists(riaLinkList), "Expected clean to have deleted " + riaLinkList);
// Step 3: verify redundant clean does no harm and succeeds
success = cleanTask.Execute();
Assert.IsTrue(success, "Clean task returned false");
}
finally
{
CodeGenHelper.DeleteTempFolder(task);
}
}
/// <summary>
/// Creates a new CreateOpenRiaClientFilesTask 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 CreateOpenRiaClientFilesTask CreateOpenRiaClientFilesTaskInstance_CopyClientProjectToOutput(string serverProjectPath, string clientProjectPath, bool includeClientOutputAssembly)
{
CreateOpenRiaClientFilesTask task = new CreateOpenRiaClientFilesTask();
MockBuildEngine mockBuildEngine = new MockBuildEngine();
task.BuildEngine = mockBuildEngine;
task.Language = "C#";
task.ServerProjectPath = serverProjectPath;
task.ServerAssemblies = new TaskItem[] { new TaskItem(CodeGenHelper.ServerClassLibOutputAssembly(task.ServerProjectPath)) };
task.ServerReferenceAssemblies = MsBuildHelper.AsTaskItems(CodeGenHelper.ServerClassLibReferences(task.ServerProjectPath)).ToArray();
task.ClientFrameworkPath = CodeGenHelper.GetSilverlightRuntimeDirectory();
// Generate the code to our deployment directory
string tempFolder = CodeGenHelper.GenerateTempFolder();
task.OutputPath = Path.Combine(tempFolder, "FileWrites");
task.GeneratedCodePath = Path.Combine(tempFolder, "Generated_Code");
string clientProjectFileName = Path.GetFileName(clientProjectPath);
string clientProjectDestPath = Path.Combine(tempFolder, clientProjectFileName);
File.Copy(clientProjectPath, clientProjectDestPath);
task.ClientProjectPath = clientProjectDestPath;
task.ClientReferenceAssemblies = MsBuildHelper.AsTaskItems(CodeGenHelper.ClientClassLibReferences(clientProjectPath, includeClientOutputAssembly)).ToArray();
task.ClientSourceFiles = MsBuildHelper.AsTaskItems(CodeGenHelper.ClientClassLibSourceFiles(clientProjectPath)).ToArray();
return task;
}
/// <summary>
/// Deletes all the files and folders created by the given CreteRiaClientFilesTask
/// </summary>
/// <param name="task"></param>
public static void DeleteTempFolder(CreateOpenRiaClientFilesTask task)
{
if (task != null)
{
string tempFolder = Path.GetDirectoryName(task.OutputPath);
DeleteTempFolder(tempFolder);
}
}
