Der Unit -Test schlägt fehl ⇐ C#

[Anonymous]

Ein Unit -Test fällt immer wieder aus, wenn ich alle Unit -Tests ausführe, fällt jedoch nicht aus, wenn ich ihn als einzelne Test ausführt. Ich habe es mit einem Kommentar unten markiert. Beim Abfeuern der Regeln über Session.fire () gibt es nur ein Objekt vom Typ iislandViewModel mit Sitzung.query (). Count () für Debug -Zwecke. Dieses Objekt wird in jedem Test -Abneigung gelöscht. Kein Unterschied beim Ausführen aller Tests oder nur eines. Was fehlt mir? < /P>
Der Test schlägt fehl

Code: Select all

[TestFixture]
public class _2ConnectionsRule1Tests : TestBase
{
public _2ConnectionsRule1Tests()
{
Setup.Rule();
}

[Test]
public void _2ConnectionsRule1_WhenTwoValidNeighbors_ShouldTriggerRule()
{
// arrange
var testIsland = CreateTestIslandMock(TestIslandEnum.TestIsland, 2);

// valid neighbors
var leftIsland = CreateTestIslandMock(TestIslandEnum.LeftIsland, 2);
var rightIsland = CreateTestIslandMock(TestIslandEnum.RightIsland, 2);

testIsland.Setup(mock => mock.GetAllVisibleNeighbors())
.Returns([leftIsland.Object, rightIsland.Object]);

// act
Session.Insert(testIsland.Object);
Session.Fire();

// assert
Verify(x => x.Rule().Fired(Times.Once));
ConnectionManagerMock.Verify(mock => mock.AddConnection(testIsland.Object, leftIsland.Object, true), Moq.Times.Once);
ConnectionManagerMock.Verify(mock => mock.AddConnection(testIsland.Object, rightIsland.Object, true), Moq.Times.Once);
}

//This fails when running whole class, but not when running the single test
[Test]
public void _2ConnectionsRule1_WhenTwoValidNeighborsAndAdditionalNeighbors_ShouldNotTriggerRule()
{
// arrange
var testIsland = CreateTestIslandMock(TestIslandEnum.TestIsland, 2);

// valid neighbors
var leftIsland = CreateTestIslandMock(TestIslandEnum.LeftIsland, 2);
var rightIsland = CreateTestIslandMock(TestIslandEnum.RightIsland, 2);

// invalid neighbor
var upIsland = CreateTestIslandMock(TestIslandEnum.UpIsland, 4);

testIsland.Setup(mock => mock.GetAllVisibleNeighbors())
.Returns([leftIsland.Object, rightIsland.Object, upIsland.Object]);

// act
Session.Insert(testIsland.Object);
Session.Fire();

// assert
Verify(x => x.Rule().Fired(Times.Never));
}

[Test]
public void _2ConnectionsRule1_WhenMoreThanTwoValidNeighbors_ShouldNotTriggerRule()
{
// similar approach here
}

[Test]
public void _2ConnectionsRule1_WhenLessThanTwoValidNeighbors_ShouldNotTriggerRule()
{
// similar approach here
}

[Test]
public void _2ConnectionsRule1_WhenNoValidNeighbors_ShouldNotTriggerRule()
{
// similar approach here
}
}
< /code>
Die testbase: < /p>
public abstract class TestBase : RulesTestFixture
{
protected Mock ConnectionManagerMock;

[OneTimeSetUp]
public void OneTimeSetup()
{
ConnectionManagerMock = new Mock(MockBehavior.Strict);
ConnectionManagerMock.SetupProperty(mock => mock.AreRulesBeingApplied, true);
ConnectionManagerMock.SetupProperty(mock => mock.RuleMessage, string.Empty);
ConnectionManagerMock.Setup(mock => mock.AddConnection(It.IsAny(), It.IsAny(), true));
Session.Insert(ConnectionManagerMock.Object);
}

[SetUp]
public void SetUp()
{

}

[TearDown]
public void TearDown()
{
Session.RetractAll(Session.Query());
}

protected Mock CreateTestIslandMock(TestIslandEnum islandEnum, int maxConnections, bool maxConnectionsReached = false)
{
return islandEnum switch
{
TestIslandEnum.TestIsland => CreateIslandMock(1, 1, maxConnections, maxConnectionsReached),
TestIslandEnum.LeftIsland => CreateIslandMock(0, 1, maxConnections, maxConnectionsReached),
TestIslandEnum.RightIsland => CreateIslandMock(2, 1, maxConnections, maxConnectionsReached),
TestIslandEnum.UpIsland => CreateIslandMock(1, 0, maxConnections, maxConnectionsReached),
TestIslandEnum.DownIsland => CreateIslandMock(1, 2, maxConnections, maxConnectionsReached),
_ => throw new ArgumentOutOfRangeException(nameof(islandEnum), islandEnum, null)
};
}

protected Mock CreateHashiPointMock(int x, int y)
{
var hashPointMock = new Mock(MockBehavior.Strict);
hashPointMock.Setup(mock =>  mock.X).Returns(x);
hashPointMock.Setup(mock => mock.Y).Returns(y);
return hashPointMock;
}

private Mock CreateIslandMock(int x, int y, int maxConnections, bool maxConnectionsReached)
{
var islandMock = new Mock(MockBehavior.Strict);
islandMock.Setup(mock => mock.Coordinates).Returns(CreateHashiPointMock(x, y).Object);
islandMock.Setup(mock => mock.MaxConnections).Returns(maxConnections);
islandMock.Setup(mock => mock.MaxConnectionsReached).Returns(maxConnectionsReached || maxConnections == 0);
islandMock.Setup(mock => mock.GetAllVisibleNeighbors()).Returns(new List());
islandMock.Setup(mock => mock.AllConnections).Returns(new ObservableCollection());
islandMock.Setup(mock => mock.RefreshIslandColor());
return islandMock;
}
}
< /code>
Die Regel: < /p>
public class _2ConnectionsRule1 : BaseRule
{
protected override string RuleMessage => TranslationSource.Instance[nameof(_2ConnectionsRule1)]!;

/// 
public override void Define()
{
IIslandViewModel island = null!;
List allNeighbors = null!;
List validNeighbors = null!;
List invalidNeighbors = null!;
IConnectionManagerViewModel connectionManager = null!;

When()
.Match(() => island, x => x.AllConnections.Count == 0 && x.MaxConnections == 2)
.Query(() => connectionManager, q => q.Match())
.Let(() => allNeighbors, () => island.GetAllVisibleNeighbors())
.Let(() => invalidNeighbors, () => allNeighbors.Where(x => !x.MaxConnectionsReached && x.MaxConnections != 2).ToList())
.Let(() => validNeighbors, () => allNeighbors.Where(x => x.MaxConnections == 2 && !x.MaxConnectionsReached).ToList())
.Having(() => invalidNeighbors.Count == 0 && validNeighbors.Count == 2);

Then()
.Do(ctx => AddConnections(island, validNeighbors, connectionManager));
}
}