Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,7 @@

<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net7.0</TargetFramework>
<TargetFramework>net11.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -2,9 +2,9 @@
{
public class DirectoryInfoMethods
{
public void CreateSubDirectories(DirectoryInfo directory, string subDirectory)
public DirectoryInfo CreateSubDirectories(DirectoryInfo directory, string subDirectory)
{
directory.CreateSubdirectory(subDirectory);
return directory.CreateSubdirectory(subDirectory);
}

public void MoveDirectories(DirectoryInfo sourceDirectory, string destDirectory)
Expand All @@ -16,7 +16,7 @@ public void EnumerateDirectories(DirectoryInfo directoryInfo)
{
foreach (var subdirectory in directoryInfo.EnumerateDirectories())
{
Console.WriteLine(subdirectory.FullName);
Console.WriteLine(subdirectory.Name);
}
}
}
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -2,22 +2,15 @@
{
public class DirectoryMethods
{
public static DirectoryInfo? CreateADirectory(string path)
public static DirectoryInfo CreateADirectory(string path)
{
try
{
if (Directory.Exists(path))
{
return new DirectoryInfo(path);
}
var newDirectory = Directory.CreateDirectory(path);
return newDirectory;
}

var newDirectory = Directory.CreateDirectory(path);
return newDirectory;
}
catch (Exception)
{
return null;
}
public static void DeleteEmptyDirectory(string path)
{
Directory.Delete(path);
}

public static void DeleteDirectory(string path)
Expand Down
Original file line number Diff line number Diff line change
@@ -1,17 +1,21 @@
using System.Security.AccessControl;
using System.Runtime.Versioning;
using System.Security.AccessControl;

namespace DirectoryAndDirectoryInfo
{
public class DirectorySecurityAndPermissions
{
public void GetSetAccessControl()
[SupportedOSPlatform("windows")]
public void GrantFullControl(string directoryPath, string identity)
{
var directoryPath = @"C:\Users\Public\CM-Demos";
var directoryInfo = new DirectoryInfo(directoryPath);

DirectorySecurity directorySecurity = directoryInfo.GetAccessControl();

directorySecurity.AddAccessRule(new FileSystemAccessRule("UserName", FileSystemRights.FullControl, AccessControlType.Allow));
directorySecurity.AddAccessRule(new FileSystemAccessRule(
identity,
FileSystemRights.FullControl,
AccessControlType.Allow));

directoryInfo.SetAccessControl(directorySecurity);
}
Expand Down
Original file line number Diff line number Diff line change
@@ -1,8 +1,61 @@
// See https://aka.ms/new-console-template for more information
using DirectoryAndDirectoryInfo;
using DirectoryAndDirectoryInfo;

var path = @"C:\Public\CM-Demos";
var path = Path.Combine(Path.GetTempPath(), "CM-Demos");

DirectoryMethods.CreateADirectory(path);
DirectoryMethods.GetFilesInDirectory(path);
DirectoryMethods.DeleteDirectory(path);
// Create a directory, then ask for the same one again
var newDirectory = Directory.CreateDirectory(path);
File.WriteAllText(Path.Combine(path, "notes.txt"), "Keep me");

var sameDirectory = Directory.CreateDirectory(path);
Console.WriteLine($"{sameDirectory.Name} exists: {sameDirectory.Exists}");
Console.WriteLine($"Files kept: {Directory.GetFiles(path).Length}");

// Delete without the recursive flag
try
{
Directory.Delete(path);
}
catch (IOException ex)
{
Console.WriteLine($"{ex.GetType().Name}: the directory is not empty");
}

// Create subdirectories
var directory = new DirectoryInfo(path);
var subDirectory = directory.CreateSubdirectory("SubFolder");

// Move a directory
var sourceDirectory = new DirectoryInfo(path);
var destDirectory = Path.Combine(Path.GetTempPath(), "CM-Demos-Moved");

sourceDirectory.MoveTo(destDirectory);

Console.WriteLine(sourceDirectory.Name);
Console.WriteLine(sourceDirectory.GetFiles().Length);
Console.WriteLine(Directory.Exists(path));

Console.WriteLine(subDirectory.Exists);

// Enumerate directories
var directoryInfo = new DirectoryInfo(destDirectory);
foreach (var subdirectory in directoryInfo.EnumerateDirectories())
{
Console.WriteLine(subdirectory.Name);
}

// Directory traversal check
var uploads = Path.Combine(destDirectory, "SubFolder");
foreach (var userInput in new[] { "report.txt", "../notes.txt", "../SubFolder2/report.txt" })
{
var resolved = SafePaths.ResolveInside(uploads, userInput);
Console.WriteLine($"{userInput} -> {(resolved is null ? "rejected" : "allowed")}");
}

// Directory security (Windows only)
if (OperatingSystem.IsWindows())
{
var identity = $@"{Environment.UserDomainName}\{Environment.UserName}";
new DirectorySecurityAndPermissions().GrantFullControl(destDirectory, identity);
}

Directory.Delete(destDirectory, true);
Original file line number Diff line number Diff line change
@@ -0,0 +1,14 @@
namespace DirectoryAndDirectoryInfo
{
public static class SafePaths
{
public static string? ResolveInside(string rootDirectory, string userInput)
{
var root = Path.TrimEndingDirectorySeparator(Path.GetFullPath(rootDirectory))
+ Path.DirectorySeparatorChar;
var fullPath = Path.GetFullPath(Path.Join(root, userInput));

return fullPath.StartsWith(root, StringComparison.Ordinal) ? fullPath : null;
}
}
}
79 changes: 58 additions & 21 deletions files-csharp/DirectoryAndDirectoryInfo/Tests/DirectoryInfoTests.cs
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,8 @@ namespace Tests
{
public class DirectoryInfoMethodsTests : IDisposable
{
private readonly string _testDirectoryPath = @"C:\Public\CM-Demos\Test";
private readonly string _testDirectoryPath =
Path.Combine(Path.GetTempPath(), "CM-Demos-Tests", Guid.NewGuid().ToString());

public DirectoryInfoMethodsTests()
{
Expand All @@ -14,61 +15,97 @@ public DirectoryInfoMethodsTests()
[Fact]
public void WhenCreateSubDirectoriesIsCalled_ShouldCreateSubDirectory()
{
// Arrange
var directoryInfoMethods = new DirectoryInfoMethods();
var directoryInfo = new DirectoryInfo(_testDirectoryPath);
var subDirectory = "SubFolder";
var subDirectoryPath = Path.Combine(_testDirectoryPath, subDirectory);
var subDirectoryPath = Path.Combine(_testDirectoryPath, "SubFolder");

// Act
directoryInfoMethods.CreateSubDirectories(directoryInfo, subDirectory);
directoryInfoMethods.CreateSubDirectories(directoryInfo, "SubFolder");

// Assert
Assert.True(Directory.Exists(subDirectoryPath));
}

[Fact]
public void GivenMissingParent_WhenCreateSubDirectoriesIsCalled_ThenParentIsCreatedToo()
{
var directoryInfoMethods = new DirectoryInfoMethods();
var parent = new DirectoryInfo(Path.Combine(_testDirectoryPath, "NotYetThere"));

var subDirectory = directoryInfoMethods.CreateSubDirectories(parent, "SubFolder");

Assert.True(Directory.Exists(parent.FullName));
Assert.True(subDirectory.Exists);
}

[Fact]
public void WhenSourceDirectoryInfoIsMoved_ShouldDeleteOldDirectoryPath()
{
// Arrange
var directoryInfoMethods = new DirectoryInfoMethods();
var sourceDirectoryPath = Path.Combine(_testDirectoryPath, "Directory");
var sourceDirectoryInfo = Directory.CreateDirectory(sourceDirectoryPath);
var destDirectoryPath = Path.Combine(_testDirectoryPath, "NewDirectory");


// Act
directoryInfoMethods.MoveDirectories(sourceDirectoryInfo, destDirectoryPath);

// Assert
Assert.False(Directory.Exists(sourceDirectoryPath));
Assert.True(Directory.Exists(destDirectoryPath));
}

[Fact]
public void WhenEnumerateDirectoriesIsCalled_ShouldPrintSubDirectoriesToConsole()
public void GivenMovedDirectory_WhenTheSameReferenceIsUsed_ThenItPointsToTheNewPath()
{
var directoryInfoMethods = new DirectoryInfoMethods();
var sourceDirectoryInfo = Directory.CreateDirectory(Path.Combine(_testDirectoryPath, "Directory"));
File.WriteAllText(Path.Combine(sourceDirectoryInfo.FullName, "notes.txt"), "x");
var subDirectory = sourceDirectoryInfo.CreateSubdirectory("SubFolder");

directoryInfoMethods.MoveDirectories(sourceDirectoryInfo, Path.Combine(_testDirectoryPath, "NewDirectory"));

Assert.Equal("NewDirectory", sourceDirectoryInfo.Name);
Assert.Single(sourceDirectoryInfo.GetFiles());
Assert.False(subDirectory.Exists);
Assert.Throws<DirectoryNotFoundException>(() => subDirectory.GetFiles());
}

[Fact]
public void GivenSubDirectoryOfItself_WhenMoveDirectoriesIsCalled_ThenIOExceptionIsThrown()
{
// Arrange
var directoryMethods = new DirectoryInfoMethods();
var directoryInfoMethods = new DirectoryInfoMethods();
var sourceDirectoryInfo = Directory.CreateDirectory(Path.Combine(_testDirectoryPath, "Directory"));

Assert.Throws<IOException>(() => directoryInfoMethods.MoveDirectories(
sourceDirectoryInfo, Path.Combine(sourceDirectoryInfo.FullName, "NewDirectory")));
}

[Fact]
public void WhenEnumerateDirectoriesIsCalled_ShouldPrintSubDirectoryNames()
{
var directoryInfoMethods = new DirectoryInfoMethods();
var directoryInfo = new DirectoryInfo(_testDirectoryPath);
directoryInfo.CreateSubdirectory("Archive");
directoryInfo.CreateSubdirectory("SubFolder");
var output = new StringWriter();
var originalOut = Console.Out;
Console.SetOut(output);

// Act
directoryMethods.EnumerateDirectories(directoryInfo);
try
{
directoryInfoMethods.EnumerateDirectories(directoryInfo);
}
finally
{
Console.SetOut(originalOut);
}

// Assert
if (!directoryInfo.GetDirectories().Any())
Assert.Equal(string.Empty, output.ToString());
var names = output.ToString().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
Assert.Equal(["Archive", "SubFolder"], names.Order());
}

public void Dispose()
{
// Clean up the test directory after tests
if (Directory.Exists(_testDirectoryPath))
{
Directory.Delete(_testDirectoryPath, true);
}
}
}
}
}
59 changes: 45 additions & 14 deletions files-csharp/DirectoryAndDirectoryInfo/Tests/DirectoryTest.cs
Original file line number Diff line number Diff line change
Expand Up @@ -2,47 +2,78 @@

namespace Tests
{
public class DirectoryMethodsTests
public class DirectoryMethodsTests : IDisposable
{
private readonly string _testDirectoryPath = @"C:\Public\CM-Demos\Test";
private readonly string _testDirectoryPath =
Path.Combine(Path.GetTempPath(), "CM-Demos-Tests", Guid.NewGuid().ToString());

public DirectoryMethodsTests()
{
Directory.CreateDirectory(_testDirectoryPath);
}

[Fact]
public void WhenCreateADirectoryIsCallled_ShouldReturnDirectoryInfo()
public void WhenCreateADirectoryIsCalled_ShouldReturnDirectoryInfo()
{
// Arrange
var path = Path.Combine(_testDirectoryPath, "test_directory");

// Act
DirectoryInfo? result = DirectoryMethods.CreateADirectory(path);
DirectoryInfo result = DirectoryMethods.CreateADirectory(path);

// Assert
Assert.NotNull(result);
Assert.True(result.Exists);
Assert.True(Directory.Exists(path));
}

[Fact]
public void WhenDeleteDirectoryIsCalled_ShouldDeletesDirectory()
public void GivenExistingDirectory_WhenCreateADirectoryIsCalledAgain_ThenItReturnsTheSameDirectoryAndKeepsItsFiles()
{
// Act
var path = Path.Combine(_testDirectoryPath, "existing");
DirectoryMethods.CreateADirectory(path);
File.WriteAllText(Path.Combine(path, "notes.txt"), "Keep me");

DirectoryInfo result = DirectoryMethods.CreateADirectory(path);

Assert.True(result.Exists);
Assert.Single(Directory.GetFiles(path));
}

[Fact]
public void GivenNonEmptyDirectory_WhenDeleteEmptyDirectoryIsCalled_ThenIOExceptionIsThrown()
{
File.WriteAllText(Path.Combine(_testDirectoryPath, "notes.txt"), "Keep me");

Assert.Throws<IOException>(() => DirectoryMethods.DeleteEmptyDirectory(_testDirectoryPath));
Assert.True(Directory.Exists(_testDirectoryPath));
}

[Fact]
public void WhenDeleteDirectoryIsCalled_ShouldDeleteDirectoryAndItsContents()
{
Directory.CreateDirectory(Path.Combine(_testDirectoryPath, "SubFolder"));
File.WriteAllText(Path.Combine(_testDirectoryPath, "notes.txt"), "Delete me");

DirectoryMethods.DeleteDirectory(_testDirectoryPath);

// Assert
Assert.False(Directory.Exists(_testDirectoryPath));
}

[Fact]
public void WhenGetFilesAndGetDirectoriesAreCalled_ShouldReturnFullPaths()
{
var filePath = Path.Combine(_testDirectoryPath, "notes.txt");
var subDirectoryPath = Path.Combine(_testDirectoryPath, "SubFolder");
File.WriteAllText(filePath, "x");
Directory.CreateDirectory(subDirectoryPath);

Assert.Equal([filePath], DirectoryMethods.GetFilesInDirectory(_testDirectoryPath));
Assert.Equal([subDirectoryPath], DirectoryMethods.GetDirectories(_testDirectoryPath));
}

public void Dispose()
{
// Clean up the test directory after tests
if (Directory.Exists(_testDirectoryPath))
{
Directory.Delete(_testDirectoryPath, true);
}
}

}
}

Loading
Loading