public void Mockfile_Create_ShouldCreateNewStream() { string fullPath = XFS.Path(@"c:\something\demo.txt"); var fileSystem = new MockFileSystem(); var sut = new MockFile(fileSystem); Assert.That(fileSystem.FileExists(fullPath), Is.False); sut.Create(fullPath).Close(); Assert.That(fileSystem.FileExists(fullPath), Is.True); }
public void MockFile_Move_ShouldMoveFileWithinMemoryFileSystem() { string sourceFilePath = XFS.Path(@"c:\something\demo.txt"); string sourceFileContent = "this is some content"; var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData> { {sourceFilePath, new MockFileData(sourceFileContent)}, {XFS.Path(@"c:\somethingelse\dummy.txt"), new MockFileData(new byte[] {0})} }); string destFilePath = XFS.Path(@"c:\somethingelse\demo1.txt"); fileSystem.File.Move(sourceFilePath, destFilePath); Assert.That(fileSystem.FileExists(destFilePath), Is.True); Assert.That(fileSystem.GetFile(destFilePath).TextContents, Is.EqualTo(sourceFileContent)); Assert.That(fileSystem.FileExists(sourceFilePath), Is.False); }
public void MockDirectory_CreateDirectory_ShouldCreatePlaceholderFileInMemoryFileSystem() { // Arrange var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData> { { @"c:\foo.txt", new MockFileData("Demo text content") } }); // Act fileSystem.Directory.CreateDirectory(@"c:\bar"); // Assert Assert.IsTrue(fileSystem.FileExists(@"c:\bar\__PLACEHOLDER__.dir")); }
public void WriteConfigFile_FileDoesntExist_ShouldCreateFile() { // arrange var testFile = Path.Combine(MockDirectory, @".tsqllintrc"); var fileSystem = new MockFileSystem(); fileSystem.AddDirectory(MockDirectory); var configFileGenerator = new ConfigFileGenerator(fileSystem); // act configFileGenerator.WriteConfigFile(testFile); // assert Assert.IsTrue(fileSystem.FileExists(testFile)); }
public void MockDirectory_CreateDirectory_ShouldCreateFolderInMemoryFileSystem() { // Arrange var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> { { @"c:\foo.txt", new MockFileData("Demo text content") } }); // Act fileSystem.Directory.CreateDirectory(@"c:\bar"); // Assert Assert.IsTrue(fileSystem.FileExists(@"c:\bar\")); Assert.IsTrue(fileSystem.AllDirectories.Any(d => d == @"c:\bar\")); }
public void MockFile_OpenWrite_ShouldCreateNewFiles() { string filePath = XFS.Path(@"c:\something\demo.txt"); string fileContent = "this is some content"; var fileSystem = new MockFileSystem(); var bytes = new UTF8Encoding(true).GetBytes(fileContent); var stream = fileSystem.File.OpenWrite(filePath); stream.Write(bytes, 0, bytes.Length); stream.Dispose(); Assert.That(fileSystem.FileExists(filePath), Is.True); Assert.That(fileSystem.GetFile(filePath).TextContents, Is.EqualTo(fileContent)); }
public void CallRemovePackageWillRemoveNupkgFile(string id, string version, string unexpectedPath) { // Arrange var fileSystem = new MockFileSystem("x:\\root"); fileSystem.AddFile(unexpectedPath); var configFileSystem = new MockFileSystem(); var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem); // Act repository.RemovePackage(PackageUtility.CreatePackage(id, version)); // Assert Assert.False(fileSystem.FileExists(unexpectedPath)); }
public void TestStoreInitialize() { var fileSystem = new MockFileSystem(); var gameobj = new GameObject("gameObj"); var bp = gameobj.AddComponent <BehaviorParameters>(); bp.BrainParameters.VectorObservationSize = 3; bp.BrainParameters.NumStackedVectorObservations = 2; bp.BrainParameters.VectorActionDescriptions = new[] { "TestActionA", "TestActionB" }; bp.BrainParameters.ActionSpec = ActionSpec.MakeDiscrete(2, 2); gameobj.AddComponent <TestAgent>(); Assert.IsFalse(fileSystem.Directory.Exists(k_DemoDirectory)); var demoRec = gameobj.AddComponent <DemonstrationRecorder>(); demoRec.Record = true; demoRec.DemonstrationName = k_DemoName; demoRec.DemonstrationDirectory = k_DemoDirectory; var demoWriter = demoRec.LazyInitialize(fileSystem); Assert.IsTrue(fileSystem.Directory.Exists(k_DemoDirectory)); Assert.IsTrue(fileSystem.FileExists(k_DemoDirectory + k_DemoName + k_ExtensionType)); var agentInfo = new AgentInfo { reward = 1f, discreteActionMasks = new[] { false, true }, done = true, episodeId = 5, maxStepReached = true, storedVectorActions = new ActionBuffers(null, new int[] { 0, 1 }), }; demoWriter.Record(agentInfo, new System.Collections.Generic.List <ISensor>()); demoRec.Close(); // Make sure close can be called multiple times demoWriter.Close(); demoRec.Close(); // Make sure trying to write after closing doesn't raise an error. demoWriter.Record(agentInfo, new System.Collections.Generic.List <ISensor>()); }
public void EntityBuilder_CreateEntity_createsEntityFile() { var solutionDirectory = @"c:\myrepo"; var fileSystem = new MockFileSystem(); fileSystem.AddDirectory(solutionDirectory); var entity = CannedGenerator.FakeBasicProduct(); var expectedFilePath = ClassPathHelper.EntityClassPath(solutionDirectory, $"{entity.Name}.cs").FullClassPath; EntityBuilder.CreateEntity(solutionDirectory, entity, fileSystem); var exists = fileSystem.FileExists(expectedFilePath); exists.Should().BeTrue(); }
public async Task UploadModel_ShouldSaveFile() { // Arrange var mockFileSystem = new MockFileSystem(); var folderPath = mockFileSystem.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".mlops"); mockFileSystem.AddFile("model.zip", new MockFileData("test")); var sut = new LocalFileModelRepository(mockFileSystem); var expectedFilePath = mockFileSystem.Path.Combine(folderPath, $"{new Guid()}.zip"); // Act await sut.UploadModelAsync(new Guid(), "model.zip"); // Assert mockFileSystem.FileExists(expectedFilePath).Should().Be(true); }
public void DeleteFileAndEmptyParentDirectoriesCorrectly() { // Arrange var fileSystem = new MockFileSystem("x:\\"); fileSystem.AddFile("foo\\bar\\hell\\x.txt"); // Act fileSystem.DeleteFileAndParentDirectoriesIfEmpty("foo\\bar\\hell\\x.txt"); // Assert Assert.False(fileSystem.FileExists("foo\\bar\\hell\\x.txt")); Assert.False(fileSystem.DirectoryExists("foo")); Assert.False(fileSystem.DirectoryExists("foo\\bar")); Assert.False(fileSystem.DirectoryExists("foo\\bar\\hell")); }
public void MockFile_AppendText_CreatesNewFileForAppendToNonExistingFile() { string filepath = XFS.Path(@"c:\something\doesnt\exist.txt"); var filesystem = new MockFileSystem(new Dictionary <string, MockFileData>()); var stream = filesystem.File.AppendText(filepath); stream.Write("New too!"); stream.Flush(); stream.Close(); var file = filesystem.GetFile(filepath); Assert.That(file.TextContents, Is.EqualTo("New too!")); Assert.That(filesystem.FileExists(filepath)); }
public void InstallCommandUsesMultipleSourcesIfSpecified() { // Arrange var fileSystem = new MockFileSystem(); var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem); installCommand.Arguments.Add("Baz"); installCommand.Source.Add("Some Source name"); installCommand.Source.Add("Some other Source"); // Act installCommand.ExecuteCommand(); // Assert Assert.True(fileSystem.FileExists(@"Baz.0.7\Baz.0.7.nupkg")); }
public void OutputProcessedOrderCsvData() { const string inputDir = @"c:\root\in"; const string inputFileName = "myfile.csv"; var inputFilePath = Path.Combine(inputDir, inputFileName); const string outputDir = @"c:\root\out"; const string outputFileName = "myfileout.csv"; var outputFilePath = Path.Combine(outputDir, outputFileName); var csvLines = new StringBuilder(); csvLines.AppendLine("OrderNumber,CustomerNumber,Description,Quantity"); csvLines.AppendLine("42, 100001, Shirt, II"); csvLines.AppendLine("43, 200002, Shorts, I"); csvLines.AppendLine("@ This is a comment"); csvLines.AppendLine(""); csvLines.Append("44, 300003, Cap, V"); var mockInputFile = new MockFileData(csvLines.ToString()); var mockFileSystem = new MockFileSystem(); mockFileSystem.AddFile(inputFilePath, mockInputFile); mockFileSystem.AddDirectory(outputDir); var sut = new CsvFileProcessor(inputFilePath, outputFilePath, mockFileSystem); sut.Process(); Assert.True(mockFileSystem.FileExists(outputFilePath)); var processedFile = mockFileSystem.GetFile(outputFilePath); var lines = processedFile.TextContents.SplitLines(); //Assert.Equal("OrderNumber,Customer,Amount", lines[0]); //Assert.Equal("42,100001,2", lines[1]); //Assert.Equal("43,200002,1", lines[2]); //Assert.Equal("44,300003,5", lines[3]); Approvals.Verify(processedFile.TextContents); }
public void TrySerializeAndDeserializeEmptyTree() { var fileSystem = new MockFileSystem(); fileSystem.Directory.CreateDirectory(Directory.GetCurrentDirectory()); string path = Path.Combine(Directory.GetCurrentDirectory(), "binary_search_tree.dat"); var serializer = new BinarySearchTreePersistable <int, int>(fileSystem); serializer.Serialize(path, new BinarySearchTree <int, int>()); Assert.True(fileSystem.FileExists(path)); var treeDeserialized = (BinarySearchTree <int, int>)serializer.Deserialize(path); Assert.True(treeDeserialized.Count == 0); }
public void WriteConfigFile_FileExists_ShouldCreateFile() { // arrange var testFile = Path.Combine(MockDirectory, @".tsqllintrc"); var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> { { testFile, new MockFileData("{}") }, }); var configFileGenerator = new ConfigFileGenerator(fileSystem); // act configFileGenerator.WriteConfigFile(testFile); // assert Assert.IsTrue(fileSystem.FileExists(testFile)); }
public void MockFile_Move_SameSourceAndTargetIsANoOp() { string sourceFilePath = XFS.Path(@"c:\something\demo.txt"); string sourceFileContent = "this is some content"; var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> { { sourceFilePath, new MockFileData(sourceFileContent) }, { XFS.Path(@"c:\somethingelse\dummy.txt"), new MockFileData(new byte[] { 0 }) } }); string destFilePath = XFS.Path(@"c:\somethingelse\demo.txt"); fileSystem.File.Move(sourceFilePath, destFilePath); Assert.That(fileSystem.FileExists(destFilePath), Is.True); Assert.That(fileSystem.GetFile(destFilePath).TextContents, Is.EqualTo(sourceFileContent)); }
public void MarkPackageDirectoryForDeletionDoesNotAddDeletemeFileWhenDirectoryRemovalSuccessful() { // Arrange IPackage package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0.0"); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); string packageDirectoryPath = pathResolver.GetPackageDirectory(package); var deleteOnRestartManager = new DeleteOnRestartManager(() => fileSystem, () => pathResolver); // Act deleteOnRestartManager.MarkPackageDirectoryForDeletion(package); // Assert Assert.False(fileSystem.DirectoryExists(packageDirectoryPath)); Assert.False(fileSystem.FileExists(packageDirectoryPath + _deletionMarkerSuffix)); }
public void UninstallingSatellitePackageRemovesCollidingRuntimeFiles() { // Arrange // Create a runtime package and a satellite package that has a dependency on the runtime package, and uses the // local suffix convention. var runtimePackage = PackageUtility.CreatePackage( "foo", "1.0.0", content: Enumerable.Empty <string>(), assemblyReferences: new[] { @"lib\ja-jp\collision.txt" }); var satellitePackage = PackageUtility.CreatePackage( "foo.ja-jp", "1.0.0", language: "ja-jp", content: Enumerable.Empty <string>(), satelliteAssemblies: new[] { @"lib\ja-jp\collision.txt" }, dependencies: new[] { new PackageDependency("foo", VersionUtility.ParseVersionSpec("[1.0.0]")) }); var packagesFolder = new MockFileSystem(@"c:\packagesFolder"); var sharedRepository = new MockSharedPackageRepository2(); var sourceRepository = new MockPackageRepository(); var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(packagesFolder), packagesFolder, sharedRepository); sourceRepository.AddPackage(runtimePackage); sourceRepository.AddPackage(satellitePackage); var projectSystem = new MockProjectSystem(); var projectLocalRepo = new PackageReferenceRepository( new MockFileSystem(@"c:\project"), "projectName", sharedRepository); var projectManager = new ProjectManager( packageManager, packageManager.PathResolver, projectSystem, projectLocalRepo); // Act Install("foo", projectManager); Install("foo.ja-jp", projectManager); Uninstall("foo.ja-jp", packageManager, projectManager); // Assert Assert.Equal(0, packagesFolder.Paths.Count); Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\ja-jp\collision.txt")); }
public void TestConfigCanMerge() { var now = DateTime.Now; var mockE1 = new Entry(@"c:\dir2\", 1, now, false); var mockE2 = new Entry(@"c:\dir2\file3", 10, now, true); var mockE3 = new Entry(@"c:\dir3\file1", 101, now, true); var mockContent = string.Join(Environment.NewLine, mockE1.ToString(), mockE2.ToString(), mockE3.ToString()); var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> { { FileSystemConfigPath, new MockFileData(mockContent) } }); var db = new Database(fileSystem); var fsp = new Provider("FileSystem"); db.Providers.Add("FileSystem", fsp); now = now.AddSeconds(1); var e1 = new Entry(@"c:\dir1\", 12, now, false); var e2 = new Entry(@"c:\dir1\file2", 34, now, true); var e3 = new Entry(@"c:\dir2\file3", 11, now, true); var e4 = new Entry(@"c:\dir3\file1", 11, now, true); fsp.Add(e1); fsp.Add(e2); fsp.Add(e3); fsp.Add(e4); Assert.IsTrue(fsp.Remove(e4.FullPath)); db.Save(100); var fsFileName = System.IO.Path.Combine(db.ConfigDir, $"{Database.ConfigFilePrefix}.FileSystem.txt"); Assert.IsTrue(fileSystem.FileExists(FileSystemConfigPath)); var configContent = fileSystem.File.ReadAllText(fsFileName); StringAssert.Contains(e1 + Environment.NewLine, configContent); StringAssert.Contains(e2 + Environment.NewLine, configContent); StringAssert.Contains(e3 + Environment.NewLine, configContent); StringAssert.Contains(mockE1 + Environment.NewLine, configContent); StringAssert.DoesNotContain(mockE2 + Environment.NewLine, configContent); StringAssert.DoesNotContain(mockE3 + Environment.NewLine, configContent); StringAssert.DoesNotContain(e4 + Environment.NewLine, configContent); }
public void CallAddPackageWillNotCreatePackageConfigEntryToPackageConfig() { // Arrange var fileSystem = new Mock <MockFileSystem>() { CallBase = true }; fileSystem.Setup(m => m.Root).Returns(@"c:\foo\"); var configFileSystem = new MockFileSystem(); var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, configFileSystem); // Act repository.AddPackage(PackageUtility.CreatePackage("A", "2.0")); // Assert Assert.False(configFileSystem.FileExists("packages.config")); }
public async Task ExecutesCorrectly() { var configFile = new ConfigFile("C:\\SFM"); var fs = new MockFileSystem(); var revisionManager = new RevisionManager(configFile, fs); fs.CreateDirectory("C:\\SFM"); fs.CreateDirectory("C:\\SFM\\ponysfm"); fs.CreateDirectory("C:\\tmp"); fs.CreateDirectory("C:\\tmp\\models"); fs.CreateFile("C:\\tmp\\models\\pony.vtf"); fs.CreateDirectory("C:\\tmp\\materials"); fs.CreateFile("C:\\tmp\\materials\\pony.vmt"); var files = new List <RevisionFileEntry> { RevisionFileEntry.FromFile("C:\\tmp\\models\\pony.vtf", fs), RevisionFileEntry.FromFile("C:\\tmp\\materials\\pony.vmt", fs) }; var revision = new Revision(1, files); await revisionManager.InstallRevision(revision, "C:\\tmp", null); Assert.IsTrue(revisionManager.VerifyInstalled(revision, null)); var list = new List <int> { 1 }; var deinstallationPresenter = new DeinstallationPresenter(revisionManager, list); await deinstallationPresenter.Execute(); Assert.IsFalse(revisionManager.VerifyInstalled(revision, null)); foreach (var file in revision.Files) { Assert.IsFalse(fs.FileExists(file.Path)); } }
public async Task TestAddFileNothingExists() { var fs = new MockFileSystem(); var options = new ServerFilesOptions { Directory = "D:\\files", TempDirectory = "D:\\temp" }; var filesManager = new ServerFilesManager(fs, Options.Create(options), GetNullLogger()); var testFileStream = new MemoryStream(_testFile1); // act var storedFile = await filesManager.AddFile(testFileStream); // assert Assert.Equal(_testFile1Hash.ToString(), storedFile.FileHash); Assert.Equal(_testFile1.Length, storedFile.Length); Assert.True(fs.FileExists($"{options.Directory}\\{_testFile1Hash}")); Assert.Empty(fs.Directory.GetFiles(options.TempDirectory)); }
public void TestStoreInitalize() { var fileSystem = new MockFileSystem(); var demoStore = new DemonstrationStore(fileSystem); Assert.IsFalse(fileSystem.Directory.Exists(DemoDirecory)); var brainParameters = new BrainParameters { vectorObservationSize = 3, numStackedVectorObservations = 2, cameraResolutions = new [] { new Resolution() }, vectorActionDescriptions = new [] { "TestActionA", "TestActionB" }, vectorActionSize = new [] { 2, 2 }, vectorActionSpaceType = SpaceType.discrete }; demoStore.Initialize(DemoName, brainParameters, "TestBrain"); Assert.IsTrue(fileSystem.Directory.Exists(DemoDirecory)); Assert.IsTrue(fileSystem.FileExists(DemoDirecory + DemoName + ExtensionType)); var agentInfo = new AgentInfo { reward = 1f, visualObservations = new List <Texture2D>(), actionMasks = new [] { false, true }, done = true, id = 5, maxStepReached = true, memories = new List <float>(), stackedVectorObservation = new List <float>() { 1f, 1f, 1f }, storedTextActions = "TestAction", storedVectorActions = new [] { 0f, 1f }, textObservation = "TestAction", }; demoStore.Record(agentInfo); demoStore.Close(); }
public void CallingCycloneDX_CreatesBomFromPackagesFile() { var mockFileSystem = new MockFileSystem(new Dictionary <string, MockFileData> { { XFS.Path(@"c:\SolutionPath\Project\packages.config"), Helpers.GetPackagesFileWithPackageReferences( new List <NugetPackage> { new NugetPackage { Name = "Package1", Version = "1.2.3" }, new NugetPackage { Name = "Package2", Version = "1.2.3" }, new NugetPackage { Name = "Package3", Version = "1.2.3" }, }) }, }); var mockHttpClient = Helpers.GetNugetMockHttpClient(new List <NugetPackage> { new NugetPackage { Name = "Package1", Version = "1.2.3" }, new NugetPackage { Name = "Package2", Version = "1.2.3" }, new NugetPackage { Name = "Package3", Version = "1.2.3" }, }); Program.fileSystem = mockFileSystem; Program.httpClient = mockHttpClient; var args = new string[] { XFS.Path(@"c:\SolutionPath\Project\packages.config"), "-o", XFS.Path(@"c:\SolutionPath") }; var exitCode = Program.Main(args); Assert.Equal((int)ExitCode.OK, exitCode); Assert.True(mockFileSystem.FileExists(XFS.Path(@"c:\SolutionPath\bom.xml"))); }
public async System.Threading.Tasks.Task BlogPostSaveTest(KeyValuePair <string, MockFileData> data, string fileName) { var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>() { { data.Key, data.Value } }); var loader = new BlogPostLoader(fileSystem, new PostSerializer()); var item = new BlogItem { Title = "title", Content = "x", Tags = new string[] { "a", "b", "c" } }; await loader.SaveBlogItem(item, fileName).ConfigureAwait(true); Assert.True(fileSystem.FileExists(AppPathInfo.BlogInputPath + fileName)); string[] fileContents = fileSystem.File.ReadAllLines(AppPathInfo.BlogInputPath + fileName); Assert.Equal("[a,b,c]", fileContents[0]); Assert.Equal("# title", fileContents[1]); Assert.Equal("x", fileContents[2]); }
public void ShouldWriteJsonToFile() { var mockProcess = new Mock <IWebbrowserOpener>(); var mockFileSystem = new MockFileSystem(); var options = new StrykerOptions { Thresholds = new Thresholds { High = 80, Low = 60, Break = 0 }, OutputPath = Directory.GetCurrentDirectory(), ReportFileName = "mutation-report" }; var reporter = new HtmlReporter(options, mockFileSystem, processWrapper: mockProcess.Object); reporter.OnAllMutantsTested(JsonReportTestHelper.CreateProjectWith()); var reportPath = Path.Combine(options.OutputPath, "reports", $"mutation-report.html"); mockFileSystem.FileExists(reportPath).ShouldBeTrue($"Path {reportPath} should exist but it does not."); }
public void ReadsFile() { // Create Mock test file var mockFile = new MockFileData("Lorem ipsum dolor sit."); // Setup Mock File System with test file var mockFileSystem = new MockFileSystem(); mockFileSystem.AddDirectory("tests"); mockFileSystem.AddFile(@"tests/text.txt", mockFile); var fileIngestService = new FileIngestService(@"tests/text.txt", mockFileSystem); var file = fileIngestService.GetFileAsText(); Assert.True(mockFileSystem.FileExists(@"tests/text.txt")); //Assert.Equal("Lorem ipsum dolor sit.", file); Approvals.Verify(file); // Uses app `Beyond Compare` or system diff tool to compare file with approved version }
public void InstallCommandInstallsPrereleasePackageIfFlagIsSpecified() { // Arrange var fileSystem = new MockFileSystem(); var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem) { Prerelease = true }; installCommand.Arguments.Add("Baz"); installCommand.Source.Add("Some Source name"); installCommand.Source.Add("Some other Source"); // Act installCommand.ExecuteCommand(); // Assert Assert.True(fileSystem.FileExists(@"Baz.0.8.1-alpha\Baz.0.8.1-alpha.nupkg")); }
public void MockFile_OpenWrite_ShouldOverwriteExistingFiles() { string filePath = XFS.Path(@"c:\something\demo.txt"); string startFileContent = "this is some content"; string endFileContent = "this is some other content"; var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData> { { filePath, new MockFileData(startFileContent) } }); var bytes = new UTF8Encoding(true).GetBytes(endFileContent); var stream = fileSystem.File.OpenWrite(filePath); stream.Write(bytes, 0, bytes.Length); stream.Close(); Assert.That(fileSystem.FileExists(filePath), Is.True); Assert.That(fileSystem.GetFile(filePath).TextContents, Is.EqualTo(endFileContent)); }
public void OutputProcessedPolicyXmlData() { // Create mock file system to test program const string inputDir = @"c:\root\in"; const string inputFileName = "myFile.csv"; string inputFilePath = Path.Combine(inputDir, inputFileName); const string outputDir = @"c:\root\out"; const string outputFileName = "myFileOut.xml"; string outputFilePath = Path.Combine(outputDir, outputFileName); // Create dummy test data to test program produces correct values StringBuilder csvLines = new StringBuilder(); csvLines.AppendLine("policy_number,policy_start_date,premiums,membership,discretionary_bonus,uplift_percentage"); csvLines.AppendLine("A100001,01/06/1986,10000,Y,1000,40"); csvLines.AppendLine("A100002,01/01/1990,12500,N,1350,37.5"); csvLines.AppendLine("A100003,31/12/1989,15250,N,1600,42"); csvLines.AppendLine("B100001,01/01/1995,12000,Y,2000,41"); csvLines.AppendLine("B100002,01/01/1970,18000,N,3000,43"); csvLines.AppendLine("B100003,20/07/1969,20000,Y,4000,45"); csvLines.AppendLine("C100001,01/01/1992,13000,N,1000,42"); csvLines.AppendLine("C100002,31/12/1989,15000,Y,2000,44"); csvLines.Append("C100003,01/01/1990,17000,Y,3000,46"); MockFileData mockInputFile = new MockFileData(csvLines.ToString()); MockFileSystem mockFileSystem = new MockFileSystem(); mockFileSystem.AddFile(inputFilePath, mockInputFile); mockFileSystem.AddDirectory(outputDir); CsvFileProcessor csvFileProcessor = new CsvFileProcessor(inputFilePath, outputFilePath, mockFileSystem); csvFileProcessor.Process(); Assert.True(mockFileSystem.FileExists(outputFilePath)); MockFileData processedFile = mockFileSystem.GetFile(outputFilePath); Approvals.Verify(processedFile.TextContents); }
public void AddConnectionString_Creates_App_Settings_File() { //Arrange var fs = new MockFileSystem(); var testObj = GetTestObject(fs); //Act testObj.AddConnectionString("MyDbContext", "MyDbContext-NewGuid", false); //Assert string expected = @"{ ""ConnectionStrings"": { ""MyDbContext"": ""Server=(localdb)\\mssqllocaldb;Database=MyDbContext-NewGuid;Trusted_Connection=True;MultipleActiveResultSets=true"" } }"; var appSettingsPath = Path.Combine(AppBase, "appsettings.json"); fs.FileExists(appSettingsPath); Assert.Equal(expected, fs.ReadAllText(appSettingsPath), ignoreCase: false, ignoreLineEndingDifferences: true); }
public void InstallCommandDoesNotUseLocalCacheIfNoCacheIsTrue() { // Arrange var fileSystem = new MockFileSystem(); var localCache = new Mock <IPackageRepository>(MockBehavior.Strict); var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, machineCacheRepository: localCache.Object) { NoCache = true }; installCommand.Arguments.Add("Baz"); installCommand.Source.Add("Some Source name"); installCommand.Source.Add("Some other Source"); // Act installCommand.ExecuteCommand(); // Assert Assert.True(fileSystem.FileExists(@"Baz.0.7\Baz.0.7.nupkg")); localCache.Verify(c => c.GetPackages(), Times.Never()); }
public void MockDirectory_CreateDirectory_ShouldCreateFolderInMemoryFileSystem() { // Arrange var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData> { { XFS.Path(@"c:\foo.txt"), new MockFileData("Demo text content") } }); // Act fileSystem.Directory.CreateDirectory(XFS.Path(@"c:\bar")); // Assert Assert.IsTrue(fileSystem.FileExists(XFS.Path(@"c:\bar\"))); Assert.IsTrue(fileSystem.AllDirectories.Any(d => d == XFS.Path(@"c:\bar\"))); }
public void MockFile_Delete_ShouldRemoveFileFromFileSystem() { const string fullPath = @"c:\something\demo.txt"; var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData> { { fullPath, new MockFileData("Demo text content") } }); var file = new MockFile(fileSystem); file.Delete(fullPath); Assert.That(fileSystem.FileExists(fullPath), Is.False); }
public void MockFile_OpenWrite_ShouldOverwriteExistingFiles() { const string filePath = @"c:\something\demo.txt"; const string startFileContent = "this is some content"; const string endFileContent = "this is some other content"; var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData> { {filePath, new MockFileData(startFileContent)} }); var bytes = new UTF8Encoding(true).GetBytes(endFileContent); var stream = fileSystem.File.OpenWrite(filePath); stream.Write(bytes, 0, bytes.Length); stream.Close(); Assert.That(fileSystem.FileExists(filePath), Is.True); Assert.That(fileSystem.GetFile(filePath).TextContents, Is.EqualTo(endFileContent)); }
public void MockFile_OpenWrite_ShouldCreateNewFiles() { const string filePath = @"c:\something\demo.txt"; const string fileContent = "this is some content"; var fileSystem = new MockFileSystem(); var bytes = new UTF8Encoding(true).GetBytes(fileContent); var stream = fileSystem.File.OpenWrite(filePath); stream.Write(bytes, 0, bytes.Length); stream.Close(); Assert.That(fileSystem.FileExists(filePath), Is.True); Assert.That(fileSystem.GetFile(filePath).TextContents, Is.EqualTo(fileContent)); }
public void Mockfile_Create_ShouldCreateNewStream() { const string fullPath = @"c:\something\demo.txt"; var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData>()); var sut = new MockFile(fileSystem); Assert.That(fileSystem.FileExists(fullPath), Is.False); sut.Create(fullPath).Close(); Assert.That(fileSystem.FileExists(fullPath), Is.True); }
public void MockFile_AppendText_CreatesNewFileForAppendToNonExistingFile() { string filepath = XFS.Path(@"c:\something\doesnt\exist.txt"); var filesystem = new MockFileSystem(new Dictionary<string, MockFileData>()); var stream = filesystem.File.AppendText(filepath); stream.Write("New too!"); stream.Flush(); stream.Close(); var file = filesystem.GetFile(filepath); Assert.That(file.TextContents, Is.EqualTo("New too!")); Assert.That(filesystem.FileExists(filepath)); }
public void GetTempFileName_Called_CreatesEmptyFileInTempDirectory() { //Arrange var fileSystem = new MockFileSystem(); var mockPath = new MockPath(fileSystem); //Act var result = mockPath.GetTempFileName(); Assert.True(fileSystem.FileExists(result)); Assert.AreEqual(0, fileSystem.FileInfo.FromFileName(result).Length); }
public void GetTempFileName_Called_CreatesEmptyFileInTempDirectory() { //Arrange var fileSystem = new MockFileSystem(); var mockPath = new MockPath(fileSystem); //Creating directory explicitly because in normal system Tempory path always exist. fileSystem.Directory.CreateDirectory(mockPath.GetTempPath()); //Act var result = mockPath.GetTempFileName(); Assert.True(fileSystem.FileExists(result)); Assert.AreEqual(0, fileSystem.FileInfo.FromFileName(result).Length); }