public void itShouldRevertNameOnUndoButOnlyForThoseThatWereRenamed()
{
string inputFile1 = @"C:\someDir\someFile1.txt";
string inputFile2 = @"C:\someDir\someFile2.txt";
string inputFile3 = @"C:\someDir\someFile3.txt";
string pattern = "preText-[n]-postText.txt";
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddFiles(inputFile1, inputFile2, inputFile3);
var fileRenameCommand = new MultiFileRenameWithPatternCommand(pattern, fileSysCommand, inputFile1, inputFile2, inputFile3);
var outputFile1 = @"C:\someDir\preText-someFile1-postText.txt";
var outputFile2 = @"C:\someDir\preText-someFile2-postText.txt";
var outputFile3 = @"C:\someDir\preText-someFile3-postText.txt";
fakeFileSystem.AddFiles(outputFile3);
fileRenameCommand.Do();
Assert.IsFalse(fileRenameCommand.DidCommandSucceed);
fileRenameCommand.Undo();
Assert.IsFalse(fakeFileSystem.FileExists(outputFile1));
Assert.IsFalse(fakeFileSystem.FileExists(outputFile2));
Assert.IsTrue(fakeFileSystem.FileExists(outputFile3));
}
public void itShouldRenameUsingDateTimeToken()
{
string inputFile1 = @"C:\someDir\someFile1.txt";
string inputFile2 = @"C:\someDir\someFile2.txt";
string pattern = "preText-[n]-[d:MMdd]-postText.txt";
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddFiles(inputFile1, inputFile2);
var renameFileCommand = new MultiFileRenameWithPatternCommand(pattern, fileSysCommand, inputFile1, inputFile2);
renameFileCommand.Do();
var computedReplacement = renameFileCommand.DateTimeReference.ToString("MMdd");
var targetFile1 = $@"C:\someDir\preText-someFile1-{computedReplacement}-postText.txt";
var targetFile2 = $@"C:\someDir\preText-someFile2-{computedReplacement}-postText.txt";
Assert.IsTrue(renameFileCommand.DidCommandSucceed);
Assert.AreEqual(renameFileCommand.RenamedFiles[inputFile1], targetFile1);
Assert.AreEqual(renameFileCommand.RenamedFiles[inputFile2], targetFile2);
Assert.IsTrue(fakeFileSystem.FileExists(targetFile1));
Assert.IsTrue(fakeFileSystem.FileExists(targetFile2));
}
public void itShouldRenameUsingFilenameToken()
{
string inputFile1 = @"C:\someDir\someFile1.txt";
string inputFile2 = @"C:\someDir\someFile2.txt";
string pattern = "preText-[n]-postText.txt";
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddFiles(inputFile1, inputFile2);
var renameFileCommand = new MultiFileRenameWithPatternCommand(pattern, fileSysCommand, inputFile1, inputFile2);
renameFileCommand.Do();
var outputFile1 = @"C:\someDir\preText-someFile1-postText.txt";
var outputFile2 = @"C:\someDir\preText-someFile2-postText.txt";
Assert.IsTrue(renameFileCommand.DidCommandSucceed);
Assert.AreEqual(renameFileCommand.RenamedFiles[inputFile1], outputFile1);
Assert.AreEqual(renameFileCommand.RenamedFiles[inputFile2], outputFile2);
Assert.IsTrue(fakeFileSystem.FileExists(outputFile1));
Assert.IsTrue(fakeFileSystem.FileExists(outputFile2));
}
public void UpdatePost_TitleIsUpdated_UpdateSlug()
{
IFileSystem testFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(testFileSystem);
Post oldPost = new Post
{
Slug = "Old-Title",
IsPublic = true,
PubDate = DateTimeOffset.Now
};
Post newPost = new Post
{
Slug = "New-Title",
IsPublic = true,
PubDate = DateTimeOffset.Now
};
testDataStore.SavePost(oldPost);
testDataStore.UpdatePost(newPost, oldPost);
Assert.True(testFileSystem.FileExists($"BlogFiles\\Posts\\{newPost.PubDate.ToFileTime()}_{newPost.Id}.xml"));
Post result = testDataStore.CollectPostInfo($"BlogFiles\\Posts\\{newPost.PubDate.ToFileTime()}_{newPost.Id}.xml");
Assert.False(testFileSystem.FileExists($"BlogFiles\\Posts\\{oldPost.PubDate.ToFileTime()}_{oldPost.Id}.xml"));
}
public void itShouldDeleteOnlyCopiedFilesOnUndo()
{
var fileSysCommand = new MockFileSystemCommand();
var sourceDir = @"c:\sourceDir";
var sourceDirFile1 = @"c:\sourceDir\file1.txt";
var sourceDirFile2 = @"c:\sourceDir\file2.txt";
var targetDir = @"c:\targetDir";
var targetDirFile1 = @"c:\targetDir\file2.txt";
var dirCopyContentsCommand = new DirectoryCopyContentsCommand(sourceDir, targetDir, fileSysCommand);
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddDirectory(sourceDir);
fakeFileSystem.AddFiles(sourceDirFile1);
fakeFileSystem.AddFiles(sourceDirFile2);
fakeFileSystem.AddDirectory(targetDir);
fakeFileSystem.AddFiles(targetDirFile1);
dirCopyContentsCommand.Do();
Assert.IsFalse(dirCopyContentsCommand.DidCommandSucceed);
Assert.IsTrue(fakeFileSystem.FileExists(targetDirFile1));
dirCopyContentsCommand.Undo();
Assert.IsFalse(fakeFileSystem.FileExists(@"c:\targetDir\file1.txt"));
Assert.IsTrue(fakeFileSystem.FileExists(targetDirFile1));
}
public void Filesys_Add()
{
var fs = new FakeFileSystem()
.Dir("foo")
.File("foo.py", @"print('Howdy')" + "\r\n")
.File("bar.py", @"def foo():\r\n pass\r\n")
.End()
.Dir("end")
.End();
Assert.True(fs.FileExists("\\foo\\foo.py"));
Assert.False(fs.FileExists("\\foo\\foo1.py"));
Assert.False(fs.FileExists("\\bar\\foo1.py"));
}
public void itShouldRestoreBackupOnUndo()
{
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
var fileToDelete = @"c:\dummysourcefile.txt";
fakeFileSystem.AddFiles(fileToDelete);
var fileDeleteCommand = new FileDeleteCommand(@"c:\dummybackupdir", fileSysCommand, fileToDelete);
fileDeleteCommand.Do();
Assert.IsFalse(fakeFileSystem.FileExists(fileToDelete));
fileDeleteCommand.Undo();
Assert.IsTrue(fakeFileSystem.FileExists(fileToDelete));
}
public void itShouldDeleteTargetZipOnUndoIfCommandSucceeded()
{
var zipExe = "dummy7zip.exe";
var targetZipFile = @"dummytargetZip.7z";
var source1 = "file1.txt";
var source2 = "file2.txt";
var zip7FileCompressionCommand = new Zip7CompressCommand(zipExe, targetZipFile, source1, source2);
zip7FileCompressionCommand.setFileCompressionStrategy(new MockFileCompressionStrategy(0));
var mockFileSysCommand = new MockFileSystemCommand();
zip7FileCompressionCommand.setFileSystemCommandsStrategy(mockFileSysCommand);
var fakeFileSystem = new FakeFileSystem(mockFileSysCommand);
fakeFileSystem.AddFiles(source1);
fakeFileSystem.AddFiles(source2);
fakeFileSystem.AddFiles(zipExe);
zip7FileCompressionCommand.Do();
Assert.IsTrue(zip7FileCompressionCommand.DidCommandSucceed);
fakeFileSystem.AddFiles(targetZipFile);
zip7FileCompressionCommand.Undo();
Assert.IsFalse(fakeFileSystem.FileExists(targetZipFile));
}
public void UpdatePost_TitleIsUpdated_UpdateSlug()
{
IFileSystem testFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(new FakeFileSystem());
SlugGenerator slugGenerator = new SlugGenerator(testDataStore);
ExcerptGenerator excerptGenerator = new ExcerptGenerator();
Post post = new Post()
{
Slug = "Title",
IsPublic = true,
PubDate = DateTimeOffset.Now,
};
testDataStore.SavePost(post);
EditedPostModel editedPost = new EditedPostModel()
{
Title = "Edited Title",
};
EditModel model = new EditModel(testDataStore, slugGenerator, excerptGenerator);
model.OnPostPublish(post.Id, true);
testDataStore.UpdatePost(post, post.IsPublic);
Assert.True(testFileSystem.FileExists($"BlogFiles\\Posts\\{post.PubDate.ToFileTime()}_{post.Id}.xml"));
Post result = testDataStore.CollectPostInfo($"BlogFiles\\Posts\\{post.PubDate.ToFileTime()}_{post.Id}.xml");
Assert.Equal("Edited-Title", post.Slug);
}
public void SaveComment_SaveSimpleComment()
{
IFileSystem testFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(testFileSystem);
Post testPost = new Post
{
Slug = "Test-slug",
Title = "Test title",
Body = "Test body",
PubDate = DateTime.Now,
LastModified = DateTime.Now,
IsPublic = true,
Excerpt = "Test excerpt"
};
Comment testComment = new Comment
{
AuthorName = "Test name",
AuthorEmail = "Test email",
Body = "Test body",
PubDate = DateTime.Now,
IsPublic = true
};
testDataStore.SavePost(testPost);
Assert.True(testFileSystem.FileExists("BlogFiles\\Test-slug.xml"));
StringReader xmlFileContents = new StringReader(testFileSystem.ReadFileText("BlogFiles\\Test-slug.xml"));
XDocument doc = XDocument.Load(xmlFileContents);
Assert.True(doc.Root.Elements("Comments").Any());
}
public void UpdatePost_ChangePost_UpdatesXMLFile()
{
IFileSystem fakeFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(fakeFileSystem);
Post oldPost = new Post
{
Slug = "Old-Title",
Title = "Old Title",
Body = "Old body",
IsPublic = true,
Excerpt = "Old excerpt"
};
Post newPost = new Post
{
Slug = "New-Title",
Title = "New Title",
Body = "New body",
IsPublic = true,
Excerpt = "New excerpt"
};
testDataStore.SavePost(oldPost);
testDataStore.UpdatePost(newPost, oldPost);
Assert.True(fakeFileSystem.FileExists($"BlogFiles\\New-Title.xml"));
Post result = testDataStore.CollectPostInfo($"BlogFiles\\New-Title.xml");
Assert.Equal(result.Slug, "New-Title");
Assert.Equal(result.Title, "New Title");
Assert.Equal(result.Body, "New body");
Assert.True(result.IsPublic);
Assert.Equal(result.Excerpt, "New excerpt");
}
public void SaveComment_SaveSimpleComment()
{
IFileSystem testFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(testFileSystem);
Post testPost = new Post
{
Slug = "Test-slug",
Title = "Test title",
Body = "Test body",
PubDate = DateTimeOffset.Now,
LastModified = DateTimeOffset.Now,
IsPublic = true,
Excerpt = "Test excerpt"
};
Comment testComment = new Comment
{
AuthorName = "Test name",
Body = "Test body",
PubDate = DateTimeOffset.Now,
IsPublic = true
};
testPost.Comments.Add(testComment);
testDataStore.SavePost(testPost);
string filePath = $"BlogFiles\\Posts\\{testPost.PubDate.UtcDateTime.ToString("s").Replace(":", "-")}_{testPost.Id}.xml";
Assert.True(testFileSystem.FileExists(filePath));
StringReader xmlFileContents = new StringReader(testFileSystem.ReadFileText(filePath));
XDocument doc = XDocument.Load(xmlFileContents);
Assert.True(doc.Root.Elements("Comments").Any());
}
public void UpdatePost_ChangePost_DoesNotRemoveComments()
{
IFileSystem testFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(testFileSystem);
Post oldPost = new Post
{
Slug = "Old-Title",
Title = "Old Title",
Body = "Old body",
IsPublic = true,
Excerpt = "Old excerpt"
};
Comment comment = new Comment
{
AuthorName = "Test name",
AuthorEmail = "Test email",
Body = "test body",
PubDate = DateTime.Now,
IsPublic = true
};
Post newPost = new Post
{
Slug = "New-Title",
Title = "New Title",
Body = "New body",
IsPublic = true,
Excerpt = "New excerpt"
};
oldPost.Comments.Add(comment);
testDataStore.SavePost(oldPost);
newPost.Comments = oldPost.Comments;
testDataStore.UpdatePost(newPost, oldPost);
Post result = testDataStore.GetPost(newPost.Slug);
List <Comment> comments = testDataStore.GetAllComments(newPost.Slug);
Assert.True(testFileSystem.FileExists(@"BlogFiles\New-Title.xml"));
Assert.False(testFileSystem.FileExists(@"BlogFiles\Old-Title.xml"));
Assert.NotEmpty(comments);
}
public void itMustDeleteDirectoryContentsOnly()
{
var fileSysCommand = new MockFileSystemCommand();
var dirToDeleteContents = @"c:\maindir\subdir";
var dirDeleteDirContentsOnlyCommand = new DirectoryDeleteContentsOnlyCommandInternal(dirToDeleteContents, @"c:\dummybackupdir", fileSysCommand);
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddDirectory(dirToDeleteContents);
var file1 = dirToDeleteContents + @"\dummyfile1.txt";
var file2 = dirToDeleteContents + @"\dummyfile2.txt";
fakeFileSystem.AddFiles(file1);
fakeFileSystem.AddFiles(file2);
dirDeleteDirContentsOnlyCommand.Do();
Assert.IsTrue(dirDeleteDirContentsOnlyCommand.DidCommandSucceed);
Assert.IsTrue(fakeFileSystem.DirectoryExists(dirToDeleteContents));
Assert.IsFalse(fakeFileSystem.FileExists(file1));
Assert.IsFalse(fakeFileSystem.FileExists(file2));
}
public void itShouldAllowMultipleFileCopyPairs()
{
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
var fileToCopy1 = @"c:\dummysourcefile.txt";
var targetFileCopy1 = @"c:\somefolder\dummytargetfile.doc";
var fileToCopy2 = @"c:\dummysourcefile2.txt";
var targetFileCopy2 = @"c:\somefolder\dummytargetfile2.doc";
fakeFileSystem.AddFiles(fileToCopy1, fileToCopy2);
var fileCopyCommand = new FileCopyCommand(@"c:\dummybackupdir", fileSysCommand, fileToCopy1, targetFileCopy1, fileToCopy2, targetFileCopy2);
Assert.IsTrue(!fakeFileSystem.FileExists(targetFileCopy1));
Assert.IsTrue(!fakeFileSystem.FileExists(targetFileCopy2));
fileCopyCommand.Do();
Assert.IsTrue(fakeFileSystem.FileExists(targetFileCopy1));
Assert.IsTrue(fakeFileSystem.FileExists(targetFileCopy2));
}
public void itShouldFailIfSourceFileDoesNotExist()
{
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
var fileToCopy = @"c:\dummysourcefile.txt";
var targetFileCopy = @"c:\somefolder\dummysourcefile.doc";
var fileCopyCommand = new FileCopyCommand(@"c:\dummybackupdir", fileSysCommand, fileToCopy, targetFileCopy);
fileCopyCommand.Do();
Assert.IsFalse(fileCopyCommand.DidCommandSucceed);
Assert.IsFalse(fakeFileSystem.FileExists(targetFileCopy));
}
public void SaveFiles_CreatesFilesInUploadsFolder()
{
FakeFormFile file1 = new FakeFormFile();
file1.FileName = "file1";
file1.Length = 5;
FakeFormFile file2 = new FakeFormFile();
file2.FileName = "file2";
file2.Length = 5;
List <IFormFile> files = new List <IFormFile>();
files.Add(file1);
files.Add(file2);
IFileSystem testFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(testFileSystem);
testDataStore.SaveFiles(files);
Assert.True(testFileSystem.FileExists("wwwroot\\Uploads\\file1"));
Assert.True(testFileSystem.FileExists("wwwroot\\Uploads\\file2"));
}
public void ShouldReturnAddGacReferenceProcessorWhenFileReferenceNotFound()
{
var fs = new FakeFileSystem();
fs.FileExists(false);
_factory = new AddReferenceProcessorFactory(_solution, _processors, fs);
var request = new AddReferenceRequest
{
Reference = "Nancy.dll"
};
var processor = _factory.CreateProcessorFor(request);
processor.ShouldBeType<AddGacReferenceProcessor>();
}
public void itShouldRevertNameOnUndo()
{
string inputFile = @"C:\someDir\someFile.txt";
string pattern = "preText-[n]-postText.txt";
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddFiles(inputFile);
var fileRenameCommand = new MultiFileRenameWithPatternCommand(pattern, fileSysCommand, inputFile);
fileRenameCommand.Do();
Assert.IsTrue(fileRenameCommand.DidCommandSucceed);
var outputFile = @"C:\someDir\preText-someFile-postText.txt";
Assert.AreEqual(fileRenameCommand.RenamedFiles[inputFile], outputFile);
Assert.IsTrue(fakeFileSystem.FileExists(outputFile));
Assert.IsFalse(fakeFileSystem.FileExists(inputFile));
fileRenameCommand.Undo();
Assert.IsFalse(fakeFileSystem.FileExists(outputFile));
Assert.IsTrue(fakeFileSystem.FileExists(inputFile));
}
public void ShouldReturnAddGacReferenceProcessorWhenFileReferenceNotFound()
{
var fs = new FakeFileSystem();
fs.FileExists(false);
_factory = new AddReferenceProcessorFactory(_solution, _processors, fs);
var request = new AddReferenceRequest
{
Reference = "Nancy.dll"
};
var processor = _factory.CreateProcessorFor(request);
processor.ShouldBeType <AddGacReferenceProcessor>();
}
public void itShouldDeleteBackupFileOnCleanup()
{
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
var fileToDelete = @"c:\dummysourcefile.txt";
fakeFileSystem.AddFiles(fileToDelete);
var fileDeleteCommand = new FileDeleteCommand(@"c:\dummybackupdir", fileSysCommand, fileToDelete);
fileDeleteCommand.Do();
fileDeleteCommand.Cleanup();
Assert.IsFalse(fakeFileSystem.FileExists(fileDeleteCommand.BackupFilename));
}
public void itShouldHaveCopiedFileIfSuccessful()
{
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
var fileToCopy = @"c:\dummysourcefile.txt";
var targetFileCopy = @"c:\somefolder\dummysourcefile.doc";
fakeFileSystem.AddFiles(fileToCopy);
var fileCopyCommand = new FileCopyCommand(@"c:\dummybackupdir", fileSysCommand, fileToCopy, targetFileCopy);
fileCopyCommand.Do();
Assert.IsTrue(fileCopyCommand.DidCommandSucceed);
Assert.IsTrue(fakeFileSystem.FileExists(targetFileCopy));
}
public void itShouldRenameUsingMultipleFilenameTokens()
{
string inputFile1 = @"C:\someDir\someFile.txt";
string pattern = "preText-[n]-postText-[n].txt";
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddFiles(inputFile1);
var renameFileCommand = new MultiFileRenameWithPatternCommand(pattern, fileSysCommand, inputFile1);
renameFileCommand.Do();
var targetFile = @"C:\someDir\preText-someFile-postText-someFile.txt";
Assert.AreEqual(renameFileCommand.RenamedFiles[inputFile1], targetFile);
Assert.IsTrue(fakeFileSystem.FileExists(targetFile));
}
public void itShouldRenameUsingFileExtensionTokenEvenIfSourceHasNoExtension()
{
string inputFile = @"C:\someDir\someFileNoExt";
string pattern = "renamed-[n][e]";
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddFiles(inputFile);
var renameFileCommand = new MultiFileRenameWithPatternCommand(pattern, fileSysCommand, inputFile);
renameFileCommand.Do();
Assert.IsTrue(renameFileCommand.DidCommandSucceed);
var outputFile = $@"C:\someDir\renamed-someFileNoExt";
Assert.AreEqual(renameFileCommand.RenamedFiles[inputFile], outputFile);
Assert.IsTrue(fakeFileSystem.FileExists(outputFile));
}
public void itShouldSucceedWhenThereAreNoReplacementTokens()
{
string inputFile = @"C:\someDir\someFile.txt";
string pattern = "newFileName.txt";
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddFiles(inputFile);
var fileRenameCommand = new MultiFileRenameWithPatternCommand(pattern, fileSysCommand, inputFile);
fileRenameCommand.Do();
Assert.IsTrue(fileRenameCommand.DidCommandSucceed);
var outputFile = @"C:\someDir\newFileName.txt";
Assert.AreEqual(fileRenameCommand.RenamedFiles[inputFile], outputFile);
Assert.IsTrue(fakeFileSystem.FileExists(outputFile));
}
public void SavePost_SaveSimplePost()
{
IFileSystem testFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(testFileSystem);
Post testPost = new Post {
Slug = "Test-Post-Slug",
Title = "Test Title",
Body = "Test contents",
};
testDataStore.SavePost(testPost);
Assert.True(testFileSystem.FileExists("BlogFiles\\Test-Post-Slug.xml"));
Post result = testDataStore.GetPost("Test-Post-Slug");
Assert.Equal("Test-Post-Slug", result.Slug);
Assert.Equal("Test Title", result.Title);
Assert.Equal("Test contents", result.Body);
}
public void itShouldRenameUsingFilenameAndDateTimeToken()
{
string inputFile = @"C:\someDir\someFile.txt";
string pattern = "preText-[n]-postText-[d:MMdd].txt";
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
fakeFileSystem.AddFiles(inputFile);
var renameFileCommand = new MultiFileRenameWithPatternCommand(pattern, fileSysCommand, inputFile);
renameFileCommand.Do();
Assert.IsTrue(renameFileCommand.DidCommandSucceed);
var computedReplacement = renameFileCommand.DateTimeReference.ToString("MMdd");
var outputFile = $@"C:\someDir\preText-someFile-postText-{computedReplacement}.txt";
Assert.AreEqual(renameFileCommand.RenamedFiles[inputFile], outputFile);
Assert.IsTrue(fakeFileSystem.FileExists(outputFile));
}
public void SavePost_NoExcerptIsEntered_AutoGenerateExcerpt()
{
IFileSystem fakeFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(fakeFileSystem);
Post newPost = new Post
{
Title = "Title",
Body = "This is the body of my post",
};
testDataStore.SavePost(newPost);
Assert.True(fakeFileSystem.FileExists($"BlogFiles\\Title.xml"));
Post result = testDataStore.CollectPostInfo($"BlogFiles\\Title.xml");
Assert.Equal(result.Body, "This is the body of my post");
Assert.Equal(result.Excerpt, "This ");
}
public void itShouldNotDeleteTargetZipOnUndoIfCommandFailed()
{
var targetZipFile = @"dummytargetZip.7z";
var zip7FileCompressionCommand = new Zip7CompressCommand("dummy7zip.exe", targetZipFile, "file1.txt", "file2.txt");
zip7FileCompressionCommand.setFileCompressionStrategy(new MockFileCompressionStrategy(1));
var mockFileSysCommand = new MockFileSystemCommand();
zip7FileCompressionCommand.setFileSystemCommandsStrategy(mockFileSysCommand);
var fakeFileSystem = new FakeFileSystem(mockFileSysCommand);
zip7FileCompressionCommand.Do();
Assert.IsFalse(zip7FileCompressionCommand.DidCommandSucceed);
fakeFileSystem.AddFiles(targetZipFile);
zip7FileCompressionCommand.Undo();
Assert.IsTrue(fakeFileSystem.FileExists(targetZipFile));
}
public void SavePost_SaveSimplePost()
{
IFileSystem testFileSystem = new FakeFileSystem();
BlogDataStore testDataStore = new BlogDataStore(testFileSystem);
Post testPost = new Post
{
Slug = "Test-Post-Slug",
Title = "Test Title",
Body = "Test contents",
IsPublic = true
};
testPost.PubDate = DateTime.UtcNow;
testDataStore.SavePost(testPost);
Assert.True(testFileSystem.FileExists($"BlogFiles\\Posts\\{testPost.PubDate.UtcDateTime.ToString("s").Replace(":","-")}_{testPost.Id}.xml"));
Post result = testDataStore.GetPost(testPost.Id);
Assert.Equal("Test-Post-Slug", result.Slug);
Assert.Equal("Test Title", result.Title);
Assert.Equal("Test contents", result.Body);
}
public void itShouldDeleteMultipleFiles()
{
var fileSysCommand = new MockFileSystemCommand();
var fakeFileSystem = new FakeFileSystem(fileSysCommand);
var fileToDelete1 = @"c:\dummysourcefile1.txt";
var fileToDelete2 = @"c:\dummysourcefile2.txt";
var fileToDelete3 = @"c:\dummysourcefile3.txt";
fakeFileSystem.AddFiles(fileToDelete1, fileToDelete2, fileToDelete3);
Assert.IsTrue(fakeFileSystem.FileExists(fileToDelete1));
Assert.IsTrue(fakeFileSystem.FileExists(fileToDelete2));
Assert.IsTrue(fakeFileSystem.FileExists(fileToDelete3));
var fileDeleteCommand = new FileDeleteCommand(@"c:\dummybackupdir", fileSysCommand, fileToDelete1, fileToDelete2, fileToDelete3);
fileDeleteCommand.Do();
Assert.IsFalse(fakeFileSystem.FileExists(fileToDelete1));
Assert.IsFalse(fakeFileSystem.FileExists(fileToDelete2));
Assert.IsFalse(fakeFileSystem.FileExists(fileToDelete3));
}
