How to Simulate Directory.CreateDirectory(path, UnixFileMode)?

[rfvgyhn]

I'm trying to test permissions on a directory on Linux. I would expect the following to throw an UnauthorizedAccessException for /parent/child but it successfully creates the directory. Is there something I need to change to test this properly?

var fileSystem = new MockFileSystem();
fileSystem.Directory.CreateDirectory("/parent", UnixFileMode.None);
fileSystem.Directory.CreateDirectory("/parent/child");

I also tried with an AccessControlStategy but ExceptionFactory.AclAccessToPathDenied throws an IOException instead of UnauthorizedAccessException. Is that expected behavior?

[vbreuss]

@rfvgyhn: Currently the UnixFileMode is only returned again, but not interpreted in any way.
After having a look at the UnixFileMode values, it seems we would have to make it possible to simulate which user or group creates and accesses the file. I am yet unsure about a good API for this. Alternatively in your use case, we could add a check explicitely for UnixFileMode.None and throw the correct exception.

[vbreuss]

What about adding a dedicated IUnixFileModeStrategy (similar to the IAccessControlStrategy) to the MockFileSystem?

public interface IUnixFileModeStrategy
{
	/// <summary>
	///     Implements a custom strategy to simulate working with the <see cref="UnixFileMode" /> in the
	///     <see cref="MockFileSystem" />.
	/// </summary>
	/// <param name="fullPath">The full path to the file or directory.</param>
	/// <param name="mode">The <see cref="UnixFileMode"/> of the file or directory.</param>
	/// <param name="requestedAccess">The requested <see cref="FileAccess"/> of the file or directory.</param>
	/// <returns>
	///     <see langword="true" /> if the requested access should be granted, otherwise <see langword="false" />.
	/// </returns>
	bool IsAccessGranted(string fullPath, UnixFileMode mode, FileAccess requestedAccess);
}

The out-of-the-box implementation could simply give access when the mode is not UnixFileMode.None. For all other scenarios you would have to provide a custom implementation of this strategy.

Would this solve your issue, @rfvgyhn?

[rfvgyhn]

Yeah, that would solve my scenario.

Another idea, though probably a lot more work and possibly not worth the effort, would be to have the ability to initialize with some sort of ActingUserDescription(int/string userId, int/string groupId). Then add overloads for FileDescription and DirectoryDescription (..., int/string ownerId, int/string groupId). If ActingUserDescription or the overloads aren't specified, it would default to Permitted as it is now. If they are provided, it could do the proper checks on UnixFileMode which would mean the user doesn't have to implement the logic themselves. That's me just thinking about the Unix use case though. I'm not sure well that could fit for a Windows use case.

I'd be happy with either solution.

[vbreuss]

I implemented the IUnixFileModeStrategy with some adaptions in #826.

With the following implementation you should be able to simulate the user and/or group and store this information alongside the file/directory when setting the unix file mode explicitely. In the IsAccessGranted method you can access the stored data from the IFileSystemExtensibility and act accordingly.

public class DefaultUnixFileModeStrategy : IUnixFileModeStrategy
{
	private string _group = "";
	private string _user = "";

	#region IUnixFileModeStrategy Members

	/// <inheritdoc cref="IUnixFileModeStrategy.IsAccessGranted(string, IFileSystemExtensibility, UnixFileMode, FileAccess)" />
	public bool IsAccessGranted(string fullPath, IFileSystemExtensibility extensibility,
		UnixFileMode mode, FileAccess requestedAccess)
	{
		UserGroup fileUserGroup = extensibility
			.RetrieveMetadata<UserGroup>(nameof(DefaultUnixFileModeStrategy))
		                          ?? new UserGroup(_user, _group);
		switch (requestedAccess)
		{
			case FileAccess.Read:
				return mode.HasFlag(UnixFileMode.OtherRead) ||
				       (mode.HasFlag(UnixFileMode.GroupRead) &&
				        string.Equals(fileUserGroup.Group, _group, StringComparison.Ordinal)) ||
				       (mode.HasFlag(UnixFileMode.UserRead) &&
				        string.Equals(fileUserGroup.User, _user, StringComparison.Ordinal));
			default:
				return mode.HasFlag(UnixFileMode.OtherWrite) ||
				       (mode.HasFlag(UnixFileMode.GroupWrite) &&
				        string.Equals(fileUserGroup.Group, _group, StringComparison.Ordinal)) ||
				       (mode.HasFlag(UnixFileMode.UserWrite) &&
				        string.Equals(fileUserGroup.User, _user, StringComparison.Ordinal));
		}
	}

	/// <inheritdoc />
	public void OnSetUnixFileMode(string fullPath, IFileSystemExtensibility extensibility,
		UnixFileMode mode)
	{
		extensibility.StoreMetadata(nameof(DefaultUnixFileModeStrategy),
			new UserGroup(_user, _group));
	}

	#endregion

	/// <summary>
	///     Simulates that the process runs under the given <paramref name="group" />.
	/// </summary>
	public DefaultUnixFileModeStrategy SimulateGroup(string group)
	{
		_group = group;
		return this;
	}

	/// <summary>
	///     Simulates that the process runs under the given <paramref name="user" />.
	/// </summary>
	public DefaultUnixFileModeStrategy SimulateUser(string user)
	{
		_user = user;
		return this;
	}

	private record UserGroup(string User, string Group);
}

I hope this works for you, @rfvgyhn

[github-actions]

This is addressed in release v4.3.0.

[github-actions]

This is addressed in release v4.3.1.