mirror of
https://github.com/OPCFoundation/UA-.NETStandard.git
synced 2026-10-19 23:58:34 +08:00
Marc Schier
eb40a59566
Drive the solution to zero warnings / zero errors with analyzers on, promote the consistently-fixed rules to error, and lock in coverage on the only line of new logic.
365 lines
16 KiB
C#
365 lines
16 KiB
C#
/* ========================================================================
|
|
* Copyright (c) 2005-2025 The OPC Foundation, Inc. All rights reserved.
|
|
*
|
|
* OPC Foundation MIT License 1.00
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* The complete license agreement can be found here:
|
|
* http://opcfoundation.org/License/MIT/1.00/
|
|
* ======================================================================*/
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using NUnit.Framework;
|
|
using Opc.Ua.Client.FileSystem;
|
|
|
|
namespace Opc.Ua.Client.Tests.FileSystem
|
|
{
|
|
/// <summary>
|
|
/// End-to-end mock-based tests for the CRUD surface of
|
|
/// <see cref="FileSystemClient"/>
|
|
/// (<c>CreateDirectoryAsync</c>/<c>CreateFileAsync</c>/
|
|
/// <c>DeleteAsync</c>/<c>MoveAsync</c>/<c>CopyAsync</c>).
|
|
/// </summary>
|
|
[TestFixture]
|
|
[Category("FileSystem")]
|
|
[Parallelizable]
|
|
public class FileSystemClientCrudTests
|
|
{
|
|
[Test]
|
|
public async Task CreateDirectoryAsyncIssuesCallWithCorrectMethodIdAndArgsAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
ScriptCreateDirectory(harness, new NodeId(7001));
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
UaDirectoryInfo dir = await client.CreateDirectoryAsync("Reports").ConfigureAwait(false);
|
|
|
|
CallMethodRequest req = SingleCallTo(
|
|
harness, Methods.FileDirectoryType_CreateDirectory);
|
|
Assert.That(req.ObjectId, Is.EqualTo(harness.Root));
|
|
req.InputArguments[0].TryGetValue(out string dirName);
|
|
Assert.That(dirName, Is.EqualTo("Reports"));
|
|
Assert.That(dir.NodeId, Is.EqualTo(new NodeId(7001)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateFileAsyncIssuesCallWithRequestFileOpenFalseAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
ScriptCreateFile(harness, new NodeId(7002));
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
UaFileInfo file = await client.CreateFileAsync("data.bin").ConfigureAwait(false);
|
|
|
|
CallMethodRequest req = SingleCallTo(harness, Methods.FileDirectoryType_CreateFile);
|
|
req.InputArguments[0].TryGetValue(out string fileName);
|
|
req.InputArguments[1].TryGetValue(out bool requestFileOpen);
|
|
Assert.That(fileName, Is.EqualTo("data.bin"));
|
|
Assert.That(requestFileOpen, Is.False,
|
|
"Server-allocated handle must never leak through CreateFileAsync.");
|
|
Assert.That(file.NodeId, Is.EqualTo(new NodeId(7002)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task CreateDirectoryAsyncCreatesIntermediateDirectoriesAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
// Each CreateDirectory call yields a fresh NodeId per call.
|
|
int counter = 0;
|
|
harness.CallHandler = req =>
|
|
{
|
|
if (req.MethodId.TryGetValue(out uint mid) &&
|
|
mid == Methods.FileDirectoryType_CreateDirectory)
|
|
{
|
|
counter++;
|
|
req.InputArguments[0].TryGetValue(out string newName);
|
|
var newId = new NodeId((uint)(8000 + counter));
|
|
harness.RegisterDirectory(req.ObjectId, new QualifiedName(newName), newId);
|
|
return new CallMethodResult
|
|
{
|
|
StatusCode = StatusCodes.Good,
|
|
OutputArguments = new[] { new Variant(newId) }.ToArrayOf()
|
|
};
|
|
}
|
|
return new CallMethodResult { StatusCode = StatusCodes.Good };
|
|
};
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
UaDirectoryInfo dir = await client
|
|
.CreateDirectoryAsync("/a/b/c", createIntermediate: true)
|
|
.ConfigureAwait(false);
|
|
|
|
Assert.That(counter, Is.EqualTo(3));
|
|
Assert.That(dir.FullPath, Is.EqualTo("/a/b/c"));
|
|
}
|
|
|
|
[Test]
|
|
public Task CreateDirectoryAsyncThrowsWhenIntermediateMissingAndFlagFalseAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
Assert.ThrowsAsync<DirectoryNotFoundException>(
|
|
async () => await client
|
|
.CreateDirectoryAsync("/a/b/c", createIntermediate: false)
|
|
.ConfigureAwait(false));
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[Test]
|
|
public Task CreateDirectoryAsyncRejectsNamespacePrefixedLeafAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
Assert.ThrowsAsync<ArgumentException>(
|
|
async () => await client
|
|
.CreateDirectoryAsync("/1:Reports")
|
|
.ConfigureAwait(false));
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeleteAsyncOnFileIssuesCallOnParentAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
NodeId fileId = harness.RegisterFile(harness.Root, new QualifiedName("data.bin"));
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
await client.DeleteAsync("/data.bin").ConfigureAwait(false);
|
|
|
|
CallMethodRequest req = SingleCallTo(
|
|
harness, Methods.FileDirectoryType_DeleteFileSystemObject);
|
|
Assert.That(req.ObjectId, Is.EqualTo(harness.Root));
|
|
req.InputArguments[0].TryGetValue(out NodeId toDelete);
|
|
Assert.That(toDelete, Is.EqualTo(fileId));
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeleteAsyncOnEmptyDirectoryWithoutRecursiveCallsServerOnceAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
harness.RegisterDirectory(harness.Root, new QualifiedName("subdir"));
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
await client.DeleteAsync("/subdir", recursive: false).ConfigureAwait(false);
|
|
|
|
Assert.That(harness.CallRequests, Has.Count.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public Task DeleteAsyncOnNonEmptyDirectoryWithoutRecursiveThrowsAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
NodeId subdir = harness.RegisterDirectory(harness.Root, new QualifiedName("subdir"));
|
|
harness.RegisterFile(subdir, new QualifiedName("file.txt"));
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
Assert.ThrowsAsync<IOException>(
|
|
async () => await client
|
|
.DeleteAsync("/subdir", recursive: false)
|
|
.ConfigureAwait(false));
|
|
// No Delete call should have been issued.
|
|
Assert.That(harness.CallRequests.Any(r =>
|
|
r.MethodId.TryGetValue(out uint mid) &&
|
|
mid == Methods.FileDirectoryType_DeleteFileSystemObject), Is.False);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeleteAsyncOnNonEmptyDirectoryWithRecursiveCallsServerOnceAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
NodeId subdir = harness.RegisterDirectory(harness.Root, new QualifiedName("subdir"));
|
|
harness.RegisterFile(subdir, new QualifiedName("file.txt"));
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
await client.DeleteAsync("/subdir", recursive: true).ConfigureAwait(false);
|
|
|
|
var deletes = harness.CallRequests
|
|
.Where(r => r.MethodId.TryGetValue(out uint mid) &&
|
|
mid == Methods.FileDirectoryType_DeleteFileSystemObject)
|
|
.ToList();
|
|
// Exactly one Delete call — server is responsible for
|
|
// recursive traversal (Part 20 §4.3.2).
|
|
Assert.That(deletes, Has.Count.EqualTo(1));
|
|
deletes[0].InputArguments[0].TryGetValue(out NodeId toDelete);
|
|
Assert.That(toDelete, Is.EqualTo(subdir));
|
|
}
|
|
|
|
[Test]
|
|
public async Task MoveAsyncIssuesMoveOrCopyOnSourceParentAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
NodeId srcDir = harness.RegisterDirectory(harness.Root, new QualifiedName("src"));
|
|
NodeId fileId = harness.RegisterFile(srcDir, new QualifiedName("data.bin"));
|
|
NodeId destDir = harness.RegisterDirectory(harness.Root, new QualifiedName("dest"));
|
|
ScriptMoveOrCopy(harness, new NodeId(9001));
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
UaFileSystemInfo moved = await client
|
|
.MoveAsync("/src/data.bin", "/dest/data.bin")
|
|
.ConfigureAwait(false);
|
|
|
|
CallMethodRequest req = SingleCallTo(harness, Methods.FileDirectoryType_MoveOrCopy);
|
|
Assert.That(req.ObjectId, Is.EqualTo(srcDir), "MoveOrCopy must be invoked on the source's parent directory.");
|
|
req.InputArguments[0].TryGetValue(out NodeId objToMove);
|
|
req.InputArguments[1].TryGetValue(out NodeId targetDirectory);
|
|
req.InputArguments[2].TryGetValue(out bool createCopy);
|
|
req.InputArguments[3].TryGetValue(out string newName);
|
|
Assert.That(objToMove, Is.EqualTo(fileId));
|
|
Assert.That(targetDirectory, Is.EqualTo(destDir));
|
|
Assert.That(createCopy, Is.False);
|
|
Assert.That(newName, Is.EqualTo("data.bin"));
|
|
Assert.That(moved.NodeId, Is.EqualTo(new NodeId(9001)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task CopyAsyncIssuesMoveOrCopyWithCreateCopyTrueAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
NodeId srcDir = harness.RegisterDirectory(harness.Root, new QualifiedName("src"));
|
|
harness.RegisterFile(srcDir, new QualifiedName("data.bin"));
|
|
harness.RegisterDirectory(harness.Root, new QualifiedName("dest"));
|
|
ScriptMoveOrCopy(harness, new NodeId(9002));
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
_ = await client
|
|
.CopyAsync("/src/data.bin", "/dest/copy.bin")
|
|
.ConfigureAwait(false);
|
|
|
|
CallMethodRequest req = SingleCallTo(harness, Methods.FileDirectoryType_MoveOrCopy);
|
|
req.InputArguments[2].TryGetValue(out bool createCopy);
|
|
req.InputArguments[3].TryGetValue(out string newName);
|
|
Assert.That(createCopy, Is.True);
|
|
Assert.That(newName, Is.EqualTo("copy.bin"));
|
|
}
|
|
|
|
[Test]
|
|
public Task DeleteAsyncMapsBadUserAccessDeniedAsync()
|
|
{
|
|
var harness = FileSystemSessionHarness.Create();
|
|
harness.RegisterFile(harness.Root, new QualifiedName("locked.bin"));
|
|
harness.CallHandler = req =>
|
|
{
|
|
if (req.MethodId.TryGetValue(out uint mid) &&
|
|
mid == Methods.FileDirectoryType_DeleteFileSystemObject)
|
|
{
|
|
return new CallMethodResult
|
|
{
|
|
StatusCode = StatusCodes.BadUserAccessDenied,
|
|
OutputArguments = Array.Empty<Variant>().ToArrayOf()
|
|
};
|
|
}
|
|
return new CallMethodResult { StatusCode = StatusCodes.Good };
|
|
};
|
|
var client = new FileSystemClient(harness.Session, harness.Root);
|
|
|
|
Assert.ThrowsAsync<UnauthorizedAccessException>(
|
|
async () => await client.DeleteAsync("/locked.bin").ConfigureAwait(false));
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
// -------- helpers ------------------------------------------------
|
|
|
|
private static void ScriptCreateDirectory(
|
|
FileSystemSessionHarness harness, NodeId newId)
|
|
{
|
|
harness.CallHandler = req =>
|
|
{
|
|
if (req.MethodId.TryGetValue(out uint mid) &&
|
|
mid == Methods.FileDirectoryType_CreateDirectory)
|
|
{
|
|
req.InputArguments[0].TryGetValue(out string newName);
|
|
harness.RegisterDirectory(
|
|
req.ObjectId, new QualifiedName(newName), newId);
|
|
return new CallMethodResult
|
|
{
|
|
StatusCode = StatusCodes.Good,
|
|
OutputArguments = new[] { new Variant(newId) }.ToArrayOf()
|
|
};
|
|
}
|
|
return new CallMethodResult { StatusCode = StatusCodes.Good };
|
|
};
|
|
}
|
|
|
|
private static void ScriptCreateFile(
|
|
FileSystemSessionHarness harness, NodeId newId)
|
|
{
|
|
harness.CallHandler = req =>
|
|
{
|
|
if (req.MethodId.TryGetValue(out uint mid) &&
|
|
mid == Methods.FileDirectoryType_CreateFile)
|
|
{
|
|
req.InputArguments[0].TryGetValue(out string newName);
|
|
harness.RegisterFile(req.ObjectId, new QualifiedName(newName), newId);
|
|
return new CallMethodResult
|
|
{
|
|
StatusCode = StatusCodes.Good,
|
|
OutputArguments = new[]
|
|
{
|
|
new Variant(newId),
|
|
new Variant(0u)
|
|
}.ToArrayOf()
|
|
};
|
|
}
|
|
return new CallMethodResult { StatusCode = StatusCodes.Good };
|
|
};
|
|
}
|
|
|
|
private static void ScriptMoveOrCopy(
|
|
FileSystemSessionHarness harness, NodeId resultNodeId)
|
|
{
|
|
harness.CallHandler = req =>
|
|
{
|
|
if (req.MethodId.TryGetValue(out uint mid) &&
|
|
mid == Methods.FileDirectoryType_MoveOrCopy)
|
|
{
|
|
req.InputArguments[3].TryGetValue(out string newName);
|
|
req.InputArguments[1].TryGetValue(out NodeId destDir);
|
|
harness.RegisterFile(destDir, new QualifiedName(newName), resultNodeId);
|
|
return new CallMethodResult
|
|
{
|
|
StatusCode = StatusCodes.Good,
|
|
OutputArguments = new[] { new Variant(resultNodeId) }.ToArrayOf()
|
|
};
|
|
}
|
|
return new CallMethodResult { StatusCode = StatusCodes.Good };
|
|
};
|
|
}
|
|
|
|
private static CallMethodRequest SingleCallTo(
|
|
FileSystemSessionHarness harness, uint methodId)
|
|
{
|
|
var matches = harness.CallRequests
|
|
.Where(r => r.MethodId.TryGetValue(out uint mid) && mid == methodId)
|
|
.ToList();
|
|
Assert.That(matches, Has.Count.EqualTo(1),
|
|
$"Expected exactly one call to method {methodId}.");
|
|
return matches[0];
|
|
}
|
|
}
|
|
}
|