Joseph Doherty
513fa1aa16
Comment/XML-doc changes only: - add summaries to ~10k test methods, fixtures, fakes and helpers (+ <param> on theories, <returns> on async Task methods, <inheritdoc/> on interface implementations the checker can resolve) - strip ~2.6k project-tracking references (WP*, P*-*, row-NN, Task N, #NN, Component-0NN) from comments, keeping the explanatory text; reword false positives in comments only - real docs on fakes implementing BCL/library interfaces (IDisposable, ILogger, IOptionsMonitor, IAsyncLifetime) - reword the last 5 src/ false positives (CWE-1236, failures-1, year-0001, M365) Only non-comment edits: four one-line nested classes split across lines so members can carry docs. Build 0 errors / 0 warnings.
523 lines
24 KiB
C#
523 lines
24 KiB
C#
using Moq;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
|
|
using ZB.MOM.WW.ScadaBridge.TemplateEngine.Services;
|
|
|
|
namespace ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests.Services;
|
|
|
|
public class InstanceServiceTests
|
|
{
|
|
private readonly Mock<ITemplateEngineRepository> _repoMock = new();
|
|
private readonly Mock<IAuditService> _auditMock = new();
|
|
private readonly InstanceService _sut;
|
|
|
|
/// <summary>Initializes the test with a mocked repository and audit service and the service under test.</summary>
|
|
public InstanceServiceTests()
|
|
{
|
|
_sut = new InstanceService(_repoMock.Object, _auditMock.Object);
|
|
}
|
|
|
|
/// <summary>Verifies that creating an instance with valid input returns success.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task CreateInstance_ValidInput_ReturnsSuccess()
|
|
{
|
|
_repoMock.Setup(r => r.GetTemplateByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new Template("TestTemplate") { Id = 1 });
|
|
_repoMock.Setup(r => r.GetInstanceByUniqueNameAsync("Inst1", It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync((Instance?)null);
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
var result = await _sut.CreateInstanceAsync("Inst1", 1, 1, null, "admin");
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.Equal("Inst1", result.Value.UniqueName);
|
|
Assert.Equal(InstanceState.Disabled, result.Value.State); // Starts disabled
|
|
_repoMock.Verify(r => r.AddInstanceAsync(It.IsAny<Instance>(), It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
|
|
/// <summary>Verifies that creating an instance with a duplicate name returns a failure.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task CreateInstance_DuplicateName_ReturnsFailure()
|
|
{
|
|
_repoMock.Setup(r => r.GetTemplateByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new Template("T") { Id = 1 });
|
|
_repoMock.Setup(r => r.GetInstanceByUniqueNameAsync("Inst1", It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new Instance("Inst1") { Id = 99 });
|
|
|
|
var result = await _sut.CreateInstanceAsync("Inst1", 1, 1, null, "admin");
|
|
|
|
Assert.True(result.IsFailure);
|
|
Assert.Contains("already exists", result.Error);
|
|
}
|
|
|
|
/// <summary>Verifies that creating an instance from a missing template returns a failure.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task CreateInstance_MissingTemplate_ReturnsFailure()
|
|
{
|
|
_repoMock.Setup(r => r.GetTemplateByIdAsync(999, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync((Template?)null);
|
|
|
|
var result = await _sut.CreateInstanceAsync("Inst1", 999, 1, null, "admin");
|
|
|
|
Assert.True(result.IsFailure);
|
|
Assert.Contains("not found", result.Error);
|
|
}
|
|
|
|
/// <summary>Verifies that overriding a locked attribute returns a failure.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAttributeOverride_LockedAttribute_ReturnsFailure()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<TemplateAttribute>
|
|
{
|
|
new("LockedAttr") { IsLocked = true }
|
|
});
|
|
|
|
var result = await _sut.SetAttributeOverrideAsync(1, "LockedAttr", "new", "admin");
|
|
|
|
Assert.True(result.IsFailure);
|
|
Assert.Contains("locked", result.Error, StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
|
|
/// <summary>Verifies that overriding a non-existent attribute returns a failure.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAttributeOverride_NonExistentAttribute_ReturnsFailure()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<TemplateAttribute>());
|
|
|
|
var result = await _sut.SetAttributeOverrideAsync(1, "Missing", "value", "admin");
|
|
|
|
Assert.True(result.IsFailure);
|
|
Assert.Contains("does not exist", result.Error);
|
|
}
|
|
|
|
/// <summary>Verifies that overriding an unlocked attribute returns success.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAttributeOverride_UnlockedAttribute_ReturnsSuccess()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<TemplateAttribute>
|
|
{
|
|
new("Threshold") { IsLocked = false }
|
|
});
|
|
_repoMock.Setup(r => r.GetOverridesByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<InstanceAttributeOverride>());
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
var result = await _sut.SetAttributeOverrideAsync(1, "Threshold", "99", "admin");
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.Equal("Threshold", result.Value.AttributeName);
|
|
Assert.Equal("99", result.Value.OverrideValue);
|
|
}
|
|
|
|
// --- SetAlarmOverrideAsync validation regression ---
|
|
|
|
private static Template TemplateWithAlarms(int id, params TemplateAlarm[] alarms)
|
|
{
|
|
var t = new Template($"T{id}") { Id = id };
|
|
foreach (var a in alarms)
|
|
{
|
|
a.TemplateId = id;
|
|
t.Alarms.Add(a);
|
|
}
|
|
return t;
|
|
}
|
|
|
|
/// <summary>Verifies that overriding a non-existent alarm returns a failure.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAlarmOverride_NonExistentAlarm_ReturnsFailure()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAllTemplatesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<Template>
|
|
{
|
|
TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10 })
|
|
});
|
|
|
|
var result = await _sut.SetAlarmOverrideAsync(1, "Missing", "{}", null, "admin");
|
|
|
|
Assert.True(result.IsFailure);
|
|
Assert.Contains("does not exist", result.Error);
|
|
_repoMock.Verify(r => r.AddInstanceAlarmOverrideAsync(
|
|
It.IsAny<InstanceAlarmOverride>(), It.IsAny<CancellationToken>()), Times.Never);
|
|
}
|
|
|
|
/// <summary>Verifies that overriding a locked alarm on a composed template returns a failure.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAlarmOverride_ComposedLockedAlarm_ReturnsFailure()
|
|
{
|
|
// The locked alarm lives in a composed module, so it is NOT a direct
|
|
// alarm of the instance's template — the old code skipped the lock check.
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
|
|
var module = TemplateWithAlarms(2, new TemplateAlarm("Fault") { Id = 20, IsLocked = true });
|
|
var host = new Template("Host") { Id = 1 };
|
|
host.Compositions.Add(new TemplateComposition("Pump") { Id = 1, ComposedTemplateId = 2 });
|
|
|
|
_repoMock.Setup(r => r.GetAllTemplatesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<Template> { host, module });
|
|
|
|
var result = await _sut.SetAlarmOverrideAsync(1, "Pump.Fault", "{}", null, "admin");
|
|
|
|
Assert.True(result.IsFailure);
|
|
Assert.Contains("locked", result.Error, StringComparison.OrdinalIgnoreCase);
|
|
_repoMock.Verify(r => r.AddInstanceAlarmOverrideAsync(
|
|
It.IsAny<InstanceAlarmOverride>(), It.IsAny<CancellationToken>()), Times.Never);
|
|
}
|
|
|
|
/// <summary>Verifies that overriding an unlocked alarm on a composed template returns success.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAlarmOverride_ComposedUnlockedAlarm_ReturnsSuccess()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
|
|
var module = TemplateWithAlarms(2, new TemplateAlarm("Fault") { Id = 20, IsLocked = false });
|
|
var host = new Template("Host") { Id = 1 };
|
|
host.Compositions.Add(new TemplateComposition("Pump") { Id = 1, ComposedTemplateId = 2 });
|
|
|
|
_repoMock.Setup(r => r.GetAllTemplatesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<Template> { host, module });
|
|
_repoMock.Setup(r => r.GetAlarmOverrideAsync(1, "Pump.Fault", It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync((InstanceAlarmOverride?)null);
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
var result = await _sut.SetAlarmOverrideAsync(1, "Pump.Fault", "{}", 2, "admin");
|
|
|
|
Assert.True(result.IsSuccess);
|
|
_repoMock.Verify(r => r.AddInstanceAlarmOverrideAsync(
|
|
It.IsAny<InstanceAlarmOverride>(), It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
|
|
/// <summary>Verifies that overriding a locked alarm declared directly on the template returns a failure.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAlarmOverride_DirectLockedAlarm_ReturnsFailure()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAllTemplatesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<Template>
|
|
{
|
|
TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10, IsLocked = true })
|
|
});
|
|
|
|
var result = await _sut.SetAlarmOverrideAsync(1, "HighTemp", "{}", null, "admin");
|
|
|
|
Assert.True(result.IsFailure);
|
|
Assert.Contains("locked", result.Error, StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
|
|
/// <summary>Verifies that setting an alarm override stores the MES-reportable override.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAlarmOverrideAsync_StoresIsMesReportableOverride()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAllTemplatesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<Template>
|
|
{
|
|
TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10, IsLocked = false })
|
|
});
|
|
_repoMock.Setup(r => r.GetAlarmOverrideAsync(1, "HighTemp", It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync((InstanceAlarmOverride?)null);
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
InstanceAlarmOverride? added = null;
|
|
_repoMock.Setup(r => r.AddInstanceAlarmOverrideAsync(
|
|
It.IsAny<InstanceAlarmOverride>(), It.IsAny<CancellationToken>()))
|
|
.Callback<InstanceAlarmOverride, CancellationToken>((o, _) => added = o);
|
|
|
|
var result = await _sut.SetAlarmOverrideAsync(
|
|
1, "HighTemp", "{}", null, "admin", isMesReportableOverride: true);
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.NotNull(added);
|
|
Assert.True(added!.IsMesReportableOverride);
|
|
Assert.True(result.Value.IsMesReportableOverride);
|
|
}
|
|
|
|
/// <summary>Verifies that a null MES-reportable override clears the existing override.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAlarmOverrideAsync_NullIsMesReportableOverride_ClearsExistingOverride()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAllTemplatesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<Template>
|
|
{
|
|
TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10, IsLocked = false })
|
|
});
|
|
|
|
var existingOverride = new InstanceAlarmOverride("HighTemp")
|
|
{
|
|
Id = 5,
|
|
InstanceId = 1,
|
|
IsMesReportableOverride = true
|
|
};
|
|
_repoMock.Setup(r => r.GetAlarmOverrideAsync(1, "HighTemp", It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(existingOverride);
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
var result = await _sut.SetAlarmOverrideAsync(
|
|
1, "HighTemp", "{}", null, "admin", isMesReportableOverride: null);
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.Null(existingOverride.IsMesReportableOverride);
|
|
Assert.Null(result.Value.IsMesReportableOverride);
|
|
_repoMock.Verify(r => r.UpdateInstanceAlarmOverrideAsync(
|
|
It.Is<InstanceAlarmOverride>(o => o.IsMesReportableOverride == null),
|
|
It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
|
|
/// <summary>Verifies that setting an alarm override updates the MES-reportable override on an existing override.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAlarmOverrideAsync_UpdatesIsMesReportableOverrideOnExisting()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAllTemplatesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<Template>
|
|
{
|
|
TemplateWithAlarms(1, new TemplateAlarm("HighTemp") { Id = 10, IsLocked = false })
|
|
});
|
|
|
|
var existingOverride = new InstanceAlarmOverride("HighTemp")
|
|
{
|
|
Id = 5,
|
|
InstanceId = 1,
|
|
IsMesReportableOverride = null
|
|
};
|
|
_repoMock.Setup(r => r.GetAlarmOverrideAsync(1, "HighTemp", It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(existingOverride);
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
var result = await _sut.SetAlarmOverrideAsync(
|
|
1, "HighTemp", "{}", 3, "admin", isMesReportableOverride: false);
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.False(existingOverride.IsMesReportableOverride);
|
|
Assert.Equal(3, existingOverride.PriorityLevelOverride);
|
|
}
|
|
|
|
/// <summary>Verifies that enabling an existing instance sets its state to enabled.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task Enable_ExistingInstance_SetsEnabled()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, State = InstanceState.Disabled };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
var result = await _sut.EnableAsync(1, "admin");
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.Equal(InstanceState.Enabled, result.Value.State);
|
|
}
|
|
|
|
/// <summary>Verifies that disabling an existing instance sets its state to disabled.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task Disable_ExistingInstance_SetsDisabled()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, State = InstanceState.Enabled };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
var result = await _sut.DisableAsync(1, "admin");
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.Equal(InstanceState.Disabled, result.Value.State);
|
|
}
|
|
|
|
/// <summary>Verifies that a bulk connection-binding assignment succeeds.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetConnectionBindings_BulkAssignment_Success()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetBindingsByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<InstanceConnectionBinding>());
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
var bindings = new List<ConnectionBinding> { new("Temp", 100), new("Pressure", 200) };
|
|
var result = await _sut.SetConnectionBindingsAsync(1, bindings, "admin");
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.Equal(2, result.Value.Count);
|
|
_repoMock.Verify(r => r.AddInstanceConnectionBindingAsync(It.IsAny<InstanceConnectionBinding>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
|
|
}
|
|
|
|
// --- ElementDataType stamping on SetAttributeOverrideAsync ---
|
|
|
|
/// <summary>Verifies that creating an override for a list attribute stamps the element data type.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAttributeOverride_CreatePath_ListAttribute_StampsElementDataType()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<TemplateAttribute>
|
|
{
|
|
new("Tags")
|
|
{
|
|
IsLocked = false,
|
|
DataType = DataType.List,
|
|
ElementDataType = DataType.String
|
|
}
|
|
});
|
|
_repoMock.Setup(r => r.GetOverridesByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<InstanceAttributeOverride>()); // no existing override → create path
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
InstanceAttributeOverride? captured = null;
|
|
_repoMock.Setup(r => r.AddInstanceAttributeOverrideAsync(It.IsAny<InstanceAttributeOverride>(), It.IsAny<CancellationToken>()))
|
|
.Callback<InstanceAttributeOverride, CancellationToken>((o, _) => captured = o);
|
|
|
|
var result = await _sut.SetAttributeOverrideAsync(1, "Tags", "[\"a\"]", "admin");
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.NotNull(captured);
|
|
Assert.Equal(DataType.String, captured.ElementDataType);
|
|
}
|
|
|
|
/// <summary>Verifies that updating an override for a list attribute stamps the element data type.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAttributeOverride_UpdatePath_ListAttribute_StampsElementDataType()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<TemplateAttribute>
|
|
{
|
|
new("Tags")
|
|
{
|
|
IsLocked = false,
|
|
DataType = DataType.List,
|
|
ElementDataType = DataType.String
|
|
}
|
|
});
|
|
|
|
var existingOverride = new InstanceAttributeOverride("Tags") { Id = 42, InstanceId = 1, OverrideValue = "[\"old\"]" };
|
|
_repoMock.Setup(r => r.GetOverridesByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<InstanceAttributeOverride> { existingOverride }); // pre-existing → update path
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
InstanceAttributeOverride? captured = null;
|
|
_repoMock.Setup(r => r.UpdateInstanceAttributeOverrideAsync(It.IsAny<InstanceAttributeOverride>(), It.IsAny<CancellationToken>()))
|
|
.Callback<InstanceAttributeOverride, CancellationToken>((o, _) => captured = o);
|
|
|
|
var result = await _sut.SetAttributeOverrideAsync(1, "Tags", "[\"new\"]", "admin");
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.NotNull(captured);
|
|
Assert.Equal(DataType.String, captured.ElementDataType);
|
|
}
|
|
|
|
/// <summary>Verifies that creating an override for a scalar attribute leaves the element data type null.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task SetAttributeOverride_CreatePath_ScalarAttribute_ElementDataTypeIsNull()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, TemplateId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAttributesByTemplateIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<TemplateAttribute>
|
|
{
|
|
new("Threshold")
|
|
{
|
|
IsLocked = false,
|
|
DataType = DataType.Float,
|
|
ElementDataType = null
|
|
}
|
|
});
|
|
_repoMock.Setup(r => r.GetOverridesByInstanceIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new List<InstanceAttributeOverride>());
|
|
_repoMock.Setup(r => r.SaveChangesAsync(It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(1);
|
|
|
|
InstanceAttributeOverride? captured = null;
|
|
_repoMock.Setup(r => r.AddInstanceAttributeOverrideAsync(It.IsAny<InstanceAttributeOverride>(), It.IsAny<CancellationToken>()))
|
|
.Callback<InstanceAttributeOverride, CancellationToken>((o, _) => captured = o);
|
|
|
|
var result = await _sut.SetAttributeOverrideAsync(1, "Threshold", "3.14", "admin");
|
|
|
|
Assert.True(result.IsSuccess);
|
|
Assert.NotNull(captured);
|
|
Assert.Null(captured.ElementDataType);
|
|
}
|
|
|
|
/// <summary>Verifies that assigning an instance to an area in a different site returns a failure.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task AssignToArea_AreaInDifferentSite_ReturnsFailure()
|
|
{
|
|
var instance = new Instance("Inst1") { Id = 1, SiteId = 1 };
|
|
_repoMock.Setup(r => r.GetInstanceByIdAsync(1, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(instance);
|
|
_repoMock.Setup(r => r.GetAreaByIdAsync(5, It.IsAny<CancellationToken>()))
|
|
.ReturnsAsync(new Area("WrongSiteArea") { Id = 5, SiteId = 99 });
|
|
|
|
var result = await _sut.AssignToAreaAsync(1, 5, "admin");
|
|
|
|
Assert.True(result.IsFailure);
|
|
Assert.Contains("does not belong", result.Error);
|
|
}
|
|
}
|