public static void run_writes_the_expected_files_to_disk() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var generalMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); generalMock.ExistsMock = () => { return(true); }; return(generalMock); }; var codegenJob = new StubCodegenJob(OutputDirectory, mockFileSystem, new List <string>() { "TestSchema.schema" }, new List <string>() { "TestOutput.h", "TestOutput.cpp" }); codegenJob.Run(); Assert.That(mockFileSystem.WriteToFileCallCount == 2); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestOutput.h"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestOutput.cpp"))); }
public static void is_dirty_returns_true_if_not_all_output_files_of_a_job_are_present() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var fileName = Path.GetFileName(path); if (fileName == "TestOutput.h") { var schemaMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); schemaMock.ExistsMock = () => { return(false); }; return(schemaMock); } var generalMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); generalMock.ExistsMock = () => { return(true); }; return(generalMock); }; var codegenJob = new StubCodegenJob(OutputDirectory, mockFileSystem, new List <string>() { "TestSchema.schema" }, new List <string>() { "TestOutput.h", "TestOutput.cpp" }); Assert.That(codegenJob.IsDirty(), "Is dirty was not true when one of the output files was missing"); }
public static void run_executes_the_expected_file_operations_when_running_an_unrealcommandjob() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var file = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); file.ExistsMock = () => { return(false); }; return(file); }; mockFileSystem.GetFilesInDirectoryMock = (path, searchpattern, recursive) => { return(new List <IFile>()); }; var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen"); var responseTypeReference = new UnrealBuiltInTypeReference(GenerateTypeReferenceRaw()); var requestTypeReference = new UnrealBuiltInTypeReference(GenerateTypeReferenceRaw()); var unrealCommandDetails = new UnrealCommandDetails(GenerateCommandDefinition(), "TestCommand", "improbable.codegen.TestComponent", "TestComponent", requestTypeReference, responseTypeReference, unrealPackageDetails); var commandJob = new UnrealCommandJob(unrealCommandDetails, Path.Combine("OutputDir", "test"), mockFileSystem); var jobRunner = new JobRunner(mockFileSystem); jobRunner.Run(new List <ICodegenJob>() { commandJob }, new List <string>() { OutputDirectory }); Assert.That(mockFileSystem.DirectoryExistsCallCount == 2); Assert.That(mockFileSystem.WriteToFileCallCount == 2); Assert.That(mockFileSystem.WrittenFiles.Count == 2); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestCommandCommandResponder.h"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestCommandCommandResponder.cpp"))); }
public static void run_executes_the_expected_file_operations_when_running_an_unrealcallbackdispatcherjob() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var file = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); file.ExistsMock = () => { return(false); }; return(file); }; mockFileSystem.GetFilesInDirectoryMock = (path, searchpattern, recursive) => { return(new List <IFile>()); }; var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", "improbable\\codegen\\Test.schema", "improbable.codegen"); var unrealComponentDetails = new UnrealComponentDetails(GenerateComponentDefinition(), "TestComponent", null, null, null, unrealPackageDetails); var callbackDispatcherJob = new UnrealCallbackDispatcherJob(new List <UnrealComponentDetails> { unrealComponentDetails }, new HashSet <string>(), Path.Combine("OutputDir", "test"), mockFileSystem); var jobRunner = new JobRunner(mockFileSystem); jobRunner.Run(new List <ICodegenJob>() { callbackDispatcherJob }, new List <string>() { OutputDirectory }); Assert.That(mockFileSystem.DirectoryExistsCallCount == 2); Assert.That(mockFileSystem.WriteToFileCallCount == 2); Assert.That(mockFileSystem.WrittenFiles.Count == 2); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(Path.Combine("OutputDir", "test"), "CallbackDispatcher.h"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(Path.Combine("OutputDir", "test"), "CallbackDispatcher.cpp"))); }
public static void run_executes_the_expected_file_operations_when_running_an_unrealenumjob() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var file = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); file.ExistsMock = () => { return(false); }; return(file); }; mockFileSystem.GetFilesInDirectoryMock = (path, searchpattern, recursive) => { return(new List <IFile>()); }; var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen"); var unrealEnumDetails = new UnrealEnumDetails(GenerateEnumDefinition(), "TestEnum", unrealPackageDetails); var enumJob = new UnrealEnumJob(unrealEnumDetails, OutputDirectory, mockFileSystem); var jobRunner = new JobRunner(mockFileSystem); jobRunner.Run(new List <ICodegenJob>() { enumJob }, new List <string>() { OutputDirectory }); Assert.That(mockFileSystem.DirectoryExistsCallCount == 1); Assert.That(mockFileSystem.WriteToFileCallCount == 1); Assert.That(mockFileSystem.WrittenFiles.Count == 1); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestEnum.h"))); }
public static void is_dirty_returns_false_if_any_of_the_output_files_is_newer_than_the_latest_schema() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var fileName = Path.GetFileName(path); if (fileName == "TestSchema.schema") { var schemaMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); schemaMock.ExistsMock = () => { return(true); }; return(schemaMock); } var generalMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 2)); generalMock.ExistsMock = () => { return(true); }; return(generalMock); }; var codegenJob = new StubCodegenJob(OutputDirectory, mockFileSystem, new List <string>() { "TestSchema.schema" }, new List <string>() { "TestOutput.h", "TestOutput.cpp" }); Assert.That(codegenJob.IsDirty() == false, "Is dirty was true when latest schema was older than newest output file"); }
public static void run_writes_the_expected_output_files_to_disk() { var fileSystem = GenerateMockFileSystem(); fileSystem.GetFileInfoMock = (path) => { var fileWrapper = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); fileWrapper.ExistsMock = () => { return(true); }; fileWrapper.DeleteMock = () => { }; return(fileWrapper); }; var schemaFileRaw = TestUtils.GetRawJsonDataFromResource <SchemaFileRaw>("Improbable.CodeGeneration.Resources.json.test.command.json"); var schemaFileProcessor = new UnrealSchemaProcessor(new List <SchemaFileRaw>() { schemaFileRaw }); var job = new UnrealCommanderJob(schemaFileProcessor.unrealCommandDetails, new HashSet <string>(), outputDir, fileSystem); job.Run(); Assert.That(fileSystem.WrittenFiles.Count == 2, "UnrealCommanderJob did not write the expected number of files"); var fullOutputDir = Path.Combine("Codegen", "Test"); Assert.That(fileSystem.WrittenFiles.Contains(Path.Combine(fullOutputDir, "Commander.h")), "UnrealCommanderJob did not write the expected files"); Assert.That(fileSystem.WrittenFiles.Contains(Path.Combine(fullOutputDir, "Commander.cpp")), "UnrealCommanderJob did not write the expected files"); }
public void SimulateFileWriting_CheckResult() { var m = new Mock <IGetFile>(); var wrapper = new MockFileWrapper(); m.Setup((x) => x.GetFile(It.IsAny <string>())).Returns(wrapper); AutoCurrentFileList autoCurrentFileList = new AutoCurrentFileList(_settingsFileWatcher, _settingsAutoCurrentFileList, m.Object); Action <object, WatcherCallbackArgs> actionFileChanges = null; Action <object> actionScanning = null; void FilterCallback(FilterAndCallbackArgument callback) { actionFileChanges = callback.ActionChanges; actionScanning = callback.ActionScanning; } var mwatcher = new Mock <IFileSystemWatcher>(); mwatcher.Setup((x) => x.Open(It.IsAny <FilterAndCallbackArgument>())).Callback((Action <FilterAndCallbackArgument>)FilterCallback).Returns(true); autoCurrentFileList.Start(mwatcher.Object); string mustBeThis = "must be this"; string lastOutput = String.Empty; string lastFileName = String.Empty; AutoResetEvent waitForInput = new AutoResetEvent(false); var task = autoCurrentFileList.BlockingReadAsyncNewOutput((output, token) => { lastOutput = output.Lines; lastFileName = output.FileName; waitForInput.Set(); }); wrapper.CurrentOutput = mustBeThis; actionFileChanges(null, new WatcherCallbackArgs("file1.txt", IFileSystemWatcherChangeType.Changed)); Assert.True(waitForInput.WaitOne(100)); Assert.True(lastOutput == mustBeThis); Assert.True(lastFileName == "file1.txt"); string mustBeThis2 = "### !CHANGED! öäüÖÄÜ ###"; wrapper.CurrentOutput = mustBeThis2; actionFileChanges(null, new WatcherCallbackArgs("file2.txt", IFileSystemWatcherChangeType.Changed)); Assert.True(waitForInput.WaitOne(100)); Assert.True(lastOutput == mustBeThis2); Assert.True(lastFileName == "file2.txt"); }
public static void clean_removes_empty_folders_in_output_directory_if_they_are_empty() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var generalMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); generalMock.ExistsMock = () => { return(true); }; generalMock.DeleteMock = () => { }; return(generalMock); }; var remainingFileCount = 2; mockFileSystem.GetFilesInDirectoryMock = (path, searchpattern, recursive) => { remainingFileCount--; if (remainingFileCount > 0) { return(new List <IFile>() { new MockFileWrapper("filetodelete", "filetodelete", new DateTime(1, 1, 1)) }); } return(new List <IFile>()); }; var deletedDirectory = string.Empty; mockFileSystem.DeleteDirectoryMock = (path) => { deletedDirectory = path; }; var codegenJob = new StubCodegenJob(OutputDirectory, mockFileSystem, new List <string>() { "TestSchema.schema" }, new List <string>() { Path.Combine("FolderToDelete", "TestOutput.h"), Path.Combine("FolderToDelete", "TestOutput.cpp") }); codegenJob.Clean(); Assert.That(mockFileSystem.GetFilesInDirectoryCallCount == 2); Assert.That(mockFileSystem.DeleteDirectoryCallCount == 1); Assert.That(deletedDirectory == Path.Combine(OutputDirectory, "FolderToDelete")); }
public static void run_does_not_clean_output_folders_of_jobs_if_the_output_folder_contains_the_files_to_be_generated() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFilesInDirectoryMock = (path, searchpatter, recursive) => { return(new List <IFile>() { new MockFileWrapper(Path.Combine(path, "TestType.h"), path, new DateTime(1, 1, 1)), new MockFileWrapper(Path.Combine(path, "TestType.cpp"), path, new DateTime(1, 1, 1)) }); }; mockFileSystem.GetFileInfoMock = (path) => { var fileMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); fileMock.ExistsMock = () => { return(true); }; return(fileMock); }; var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen"); var cleanUnrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("TestType", "improbable.codegen.TestType"), "TestType", new List <UnrealFieldDetails>(), unrealPackageDetails); var cleanTypeJob = new UnrealTypeJob(cleanUnrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), OutputDirectory, mockFileSystem); var jobRunner = new JobRunner(mockFileSystem); jobRunner.Run(new List <ICodegenJob>() { cleanTypeJob }, new List <string>() { OutputDirectory }); //This validates that the output folder was not deleted Assert.That(mockFileSystem.DeleteDirectoryCallCount == 0); Assert.That(mockFileSystem.GetFilesInDirectoryCallCount == 1); //This validates that no codegen jobs were run as they were expected to not be dirty. Assert.That(mockFileSystem.WriteToFileCallCount == 0); Assert.That(mockFileSystem.DirectoryExistsCallCount == 0); Assert.That(mockFileSystem.DirectoryExistsCallCount == 0); Assert.That(mockFileSystem.WriteToFileCallCount == 0); Assert.That(cleanTypeJob.IsDirty() == false); }
public static void clean_removes_the_expected_files() { var fileSystem = GenerateMockFileSystem(); var fileWrapperList = new List <MockFileWrapper>(); fileSystem.GetFileInfoMock = (path) => { var fileWrapper = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); fileWrapper.ExistsMock = () => { return(true); }; fileWrapper.DeleteMock = () => { }; fileWrapperList.Add(fileWrapper); return(fileWrapper); }; fileSystem.GetFilesInDirectoryMock = (path, searchpattern, recursive) => { return(new List <IFile>() { new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)) }); }; var schemaFileRaw = TestUtils.GetRawJsonDataFromResource <SchemaFileRaw>("Improbable.CodeGeneration.Resources.json.test.enum.json"); var schemaFileProcessor = new UnrealSchemaProcessor(new List <SchemaFileRaw>() { schemaFileRaw }); var job = new UnrealComponentJob(schemaFileProcessor.unrealComponentDetails.First(), outputDir, fileSystem); job.Clean(); Assert.That(fileWrapperList.Count == 5, "clean did not scan for the expected files to be deleted"); foreach (var fileWrapper in fileWrapperList) { Assert.That(fileWrapper.DeleteCallCount == 1, "Did not call Delete the expected number of times for a filewrapper"); Assert.That(fileWrapper.ExistsCallCount == 1, "Did not call Exists the expected number of times for a filewrapper"); } var fullOutputDir = Path.Combine("Codegen", "Test"); Assert.That(fileWrapperList.Exists((fileWrapper) => fileWrapper.CompletePath == Path.Combine(fullOutputDir, "ExampleEnumComponentComponent.h"))); Assert.That(fileWrapperList.Exists((fileWrapper) => fileWrapper.CompletePath == Path.Combine(fullOutputDir, "ExampleEnumComponentComponent.cpp"))); Assert.That(fileWrapperList.Exists((fileWrapper) => fileWrapper.CompletePath == Path.Combine(fullOutputDir, "ExampleEnumComponentComponentUpdate.h"))); Assert.That(fileWrapperList.Exists((fileWrapper) => fileWrapper.CompletePath == Path.Combine(fullOutputDir, "ExampleEnumComponentComponentUpdate.cpp"))); Assert.That(fileWrapperList.Exists((fileWrapper) => fileWrapper.CompletePath == Path.Combine(fullOutputDir, "ExampleEnumComponentAddComponentOp.h"))); }
public static void is_dirty_returns_true_if_there_are_no_files_in_output_folder() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var generalMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); generalMock.ExistsMock = () => { return(true); }; return(generalMock); }; var codegenJob = new StubCodegenJob(OutputDirectory, mockFileSystem, new List <string>() { "TestSchema.schema" }, new List <string>()); Assert.That(codegenJob.IsDirty(), "Is dirty was not true when output files directory was empty"); }
public static void run_creates_the_output_directory_if_it_does_not_exist() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var generalMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); generalMock.ExistsMock = () => { return(true); }; return(generalMock); }; var directoryCreated = false; var createdDirectory = string.Empty; mockFileSystem.CreateDirectoryMock = (path) => { directoryCreated = true; createdDirectory = path; }; mockFileSystem.DirectoryExistsMock = (path) => { if (directoryCreated) { return(true); } return(false); }; var codegenJob = new StubCodegenJob(OutputDirectory, mockFileSystem, new List <string>() { "TestSchema.schema" }, new List <string>() { Path.Combine("CreatedDir", "TestOutput.h"), Path.Combine("CreatedDir", "TestOutput.cpp") }); codegenJob.Run(); Assert.That(mockFileSystem.DirectoryExistsCallCount == 2); Assert.That(mockFileSystem.CreateDirectoryCallCount == 1); Assert.That(createdDirectory == Path.Combine(OutputDirectory, "CreatedDir")); }
public static void clean_deletes_the_expected_files_on_disk() { var mockFileSystem = GenerateMockFileSystem(); var mockFileWrappers = new List <MockFileWrapper>(); mockFileSystem.GetFileInfoMock = (path) => { var generalMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); generalMock.ExistsMock = () => { return(true); }; generalMock.DeleteMock = () => { }; mockFileWrappers.Add(generalMock); return(generalMock); }; mockFileSystem.GetFilesInDirectoryMock = (path, searchpattern, recursive) => { return(new List <IFile>() { new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)) }); }; var codegenJob = new StubCodegenJob(OutputDirectory, mockFileSystem, new List <string>() { "TestSchema.schema" }, new List <string>() { "TestOutput.h", "TestOutput.cpp" }); codegenJob.Clean(); Assert.That(mockFileWrappers.Count == 2); Assert.That(mockFileWrappers.Any(file => file.CompletePath == Path.Combine(OutputDirectory, "TestOutput.h"))); Assert.That(mockFileWrappers.Any(file => file.CompletePath == Path.Combine(OutputDirectory, "TestOutput.cpp"))); foreach (var fileMock in mockFileWrappers) { Assert.That(fileMock.ExistsCallCount == 1); Assert.That(fileMock.DeleteCallCount == 1); } }
public void run_does_clean_if_files_are_present_in_output_folder_that_should_not_be_there() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFilesInDirectoryMock = (path, searchpatter, recursive) => { return(new List <IFile>() { new MockFileWrapper(Path.Combine(path, "TestType.h"), path, new DateTime(1, 1, 1)), new MockFileWrapper(Path.Combine(path, "TestType.cpp"), path, new DateTime(1, 1, 1)), new MockFileWrapper(Path.Combine(path, "Invalid.cpp"), path, new DateTime(1, 1, 1)), }); }; mockFileSystem.DeleteDirectoryMock = (path) => { }; mockFileSystem.GetFileInfoMock = (path) => { var fileMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); bool fileExists = false; var fileName = Path.GetFileName(path); if (fileName == "TestType.h" || fileName == "TestType.cpp" || fileName == "Invalid.cpp") { fileExists = true; } fileMock.ExistsMock = () => { return(fileExists); }; return(fileMock); }; var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen"); var cleanUnrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("TestType", "improbable.codegen.TestType"), "TestType", new List <UnrealFieldDetails>(), unrealPackageDetails); var cleanTypeJob = new UnrealTypeJob(cleanUnrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), OutputDirectory, mockFileSystem); var dirtyUnrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("DirtyTestType", "improbable.codegen.DirtyTestType"), "DirtyTestType", new List <UnrealFieldDetails>(), unrealPackageDetails); var dirtyTypeJob = new UnrealTypeJob(dirtyUnrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), OutputDirectory, mockFileSystem); var jobRunner = new JobRunner(mockFileSystem); jobRunner.Run(new List <ICodegenJob>() { cleanTypeJob, dirtyTypeJob }, new List <string>() { OutputDirectory }); //Validate that the folder check was correct Assert.That(mockFileSystem.DeleteDirectoryCallCount == 1); Assert.That(mockFileSystem.GetFilesInDirectoryCallCount == 1); //Validate that the correct jobs were run and expected files were written Assert.That(mockFileSystem.GetFileInfoCallCount == 4); Assert.That(mockFileSystem.DirectoryExistsCallCount == 4); Assert.That(mockFileSystem.WriteToFileCallCount == 4); Assert.That(mockFileSystem.WrittenFiles.Count == 4); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.h"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.cpp"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "DirtyTestType.h"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "DirtyTestType.cpp"))); Assert.That(cleanTypeJob.IsDirty()); Assert.That(dirtyTypeJob.IsDirty()); }
public FileLoggerTest() { _mockWrapper = new MockFileWrapper(); _mockLogic = new MockFileLogic(); }
public FileLogicTests() { _mockWrapper = new MockFileWrapper(); }