public void ReconnectTeam_TeamNameAndMemberNameAndEstimationStarted_AllMembersAreEstimationParticipants()
{
// Arrange
var team = CreateBasicTeam();
var member = (D.Member)team.Join(MemberName, false);
team.ScrumMaster.StartEstimation();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = target.ReconnectTeam(TeamName, MemberName).Value;
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNotNull(result);
Assert.IsNotNull(result.ScrumTeam);
Assert.IsNotNull(result.ScrumTeam.EstimationParticipants);
var expectedParticipants = new string[] { ScrumMasterName, MemberName };
CollectionAssert.AreEqual(expectedParticipants, result.ScrumTeam.EstimationParticipants.Select(p => p.MemberName).ToList());
}
public void ReconnectTeam_TeamNameAndMemberName_ReturnsReconnectedTeam()
{
// Arrange
var team = CreateBasicTeam();
var member = team.Join(MemberName, false);
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = target.ReconnectTeam(TeamName, MemberName).Value;
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNotNull(result);
Assert.IsNotNull(result.ScrumTeam);
Assert.AreEqual <long>(0, result.LastMessageId);
Assert.AreEqual <string>(TeamName, result.ScrumTeam.Name);
Assert.IsNotNull(result.ScrumTeam.ScrumMaster);
Assert.AreEqual <string>(ScrumMasterName, result.ScrumTeam.ScrumMaster.Name);
Assert.IsNotNull(result.ScrumTeam.Members);
var expectedMembers = new string[] { ScrumMasterName, MemberName };
CollectionAssert.AreEquivalent(expectedMembers, result.ScrumTeam.Members.Select(m => m.Name).ToList());
var expectedMemberTypes = new string[] { typeof(D.ScrumMaster).Name, typeof(D.Member).Name };
CollectionAssert.AreEquivalent(expectedMemberTypes, result.ScrumTeam.Members.Select(m => m.Type).ToList());
}
public void CreateTeam_TeamNameAndScrumMasterName_ReturnsCreatedTeam()
{
// Arrange
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.CreateScrumTeam(TeamName, ScrumMasterName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = target.CreateTeam(TeamName, ScrumMasterName).Value;
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNotNull(result);
Assert.AreEqual <string>(TeamName, result.Name);
Assert.IsNotNull(result.ScrumMaster);
Assert.AreEqual <string>(ScrumMasterName, result.ScrumMaster.Name);
Assert.AreEqual <string>(typeof(D.ScrumMaster).Name, result.ScrumMaster.Type);
}
public void JoinTeam_TeamNameAndObserverNameAsObserver_ReturnsTeamJoined()
{
// Arrange
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = target.JoinTeam(TeamName, ObserverName, true).Value;
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNotNull(result);
Assert.AreEqual <string>(TeamName, result.Name);
Assert.IsNotNull(result.ScrumMaster);
Assert.AreEqual <string>(ScrumMasterName, result.ScrumMaster.Name);
Assert.IsNotNull(result.Observers);
var expectedObservers = new string[] { ObserverName };
CollectionAssert.AreEquivalent(expectedObservers, result.Observers.Select(m => m.Name).ToList());
var expectedMemberTypes = new string[] { typeof(D.Observer).Name };
CollectionAssert.AreEquivalent(expectedMemberTypes, result.Observers.Select(m => m.Type).ToList());
}
public void ReconnectTeam_TeamNameAndMemberNameWithMessages_ReturnsLastMessageId()
{
// Arrange
var team = CreateBasicTeam();
var member = team.Join(MemberName, false);
team.ScrumMaster.StartEstimation();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = target.ReconnectTeam(TeamName, MemberName).Value;
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNotNull(result);
Assert.IsNotNull(result.ScrumTeam);
Assert.AreEqual <long>(1, result.LastMessageId);
Assert.IsFalse(member.HasMessage);
}
public void ReconnectTeam_TeamNameAndMemberNameAndMemberNotEstimated_NoSelectedEstimation()
{
// Arrange
var team = CreateBasicTeam();
var member = (D.Member)team.Join(MemberName, false);
team.ScrumMaster.StartEstimation();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = target.ReconnectTeam(TeamName, MemberName).Value;
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNotNull(result);
Assert.IsNull(result.SelectedEstimation);
}
public async Task GetMessages_MemberJoinedTeam_ScrumMasterGetsMessage()
{
// Arrange
var team = CreateBasicTeam();
var member = team.Join(MemberName, false);
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
planningPoker.Setup(p => p.GetMessagesAsync(team.ScrumMaster, It.IsAny <CancellationToken>()))
.ReturnsAsync(() => team.ScrumMaster.Messages.ToList()).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = await target.GetMessages(TeamName, ScrumMasterName, 0, default(CancellationToken));
// Verify
planningPoker.Verify();
teamLock.Verify();
Assert.IsNotNull(result);
Assert.AreEqual <int>(1, result.Count);
Assert.AreEqual <long>(1, result[0].Id);
Assert.AreEqual <MessageType>(MessageType.MemberJoined, result[0].Type);
Assert.IsInstanceOfType(result[0], typeof(MemberMessage));
var memberMessage = (MemberMessage)result[0];
Assert.IsNotNull(memberMessage.Member);
Assert.AreEqual <string>(MemberName, memberMessage.Member.Name);
}
public void ReconnectTeam_TeamNameAndMemberNameAndEstimationFinished_EstimationResultIsSet()
{
// Arrange
var team = CreateBasicTeam();
var member = (D.Member)team.Join(MemberName, false);
team.ScrumMaster.StartEstimation();
member.Estimation = new D.Estimation(1);
team.ScrumMaster.Estimation = new D.Estimation(2);
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = target.ReconnectTeam(TeamName, MemberName).Value;
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNotNull(result);
Assert.IsNotNull(result.ScrumTeam);
Assert.IsNotNull(result.ScrumTeam.EstimationResult);
var expectedEstimations = new double?[] { 2, 1 };
CollectionAssert.AreEquivalent(expectedEstimations, result.ScrumTeam.EstimationResult.Select(e => e.Estimation.Value).ToList());
}
public async Task GetMessages_MemberNameIsEmpty_ArgumentNullException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
await target.GetMessages(TeamName, null, 0);
}
public void CreateTeam_TeamNameIsEmpty_ArgumentNullException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.CreateTeam(null, ScrumMasterName);
}
public void JoinTeam_TeamNameTooLong_ArgumentException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.JoinTeam(LongTeamName, MemberName, false);
}
public void JoinTeam_MemberNameIsEmpty_ArgumentNullException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.JoinTeam(TeamName, null, false);
}
public void SubmitEstimation_MemberNameTooLong_ArgumentException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.SubmitEstimation(TeamName, LongMemberName, 1.0);
}
public void DisconnectTeam_TeamNameIsEmpty_ArgumentNullException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.DisconnectTeam(null, MemberName);
}
public void StartEstimation_TeamNameIsEmpty_ArgumentNullException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.StartEstimation(null);
}
public async Task GetMessages_MemberNameTooLong_ArgumentException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
await target.GetMessages(TeamName, LongMemberName, 0, default(CancellationToken));
}
public void CancelEstimation_TeamNameTooLong_ArgumentException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.CancelEstimation(LongTeamName);
}
public void DisconnectTeam_MemberNameTooLong_ArgumentException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.DisconnectTeam(TeamName, LongMemberName);
}
public async Task GetMessages_TeamNameTooLong_ArgumentException()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
var target = new PlanningPokerService(planningPoker.Object);
// Act
await target.GetMessages(LongTeamName, MemberName, 0);
}
public void Constructor_PlanningPoker_PlanningPokerPropertyIsSet()
{
// Arrange
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
// Act
var result = new PlanningPokerService(planningPoker.Object);
// Verify
Assert.AreEqual <D.IPlanningPoker>(planningPoker.Object, result.PlanningPoker);
}
public async Task GetMessages_EstimationEnded_ScrumMasterGetsMessages()
{
// Arrange
var team = CreateBasicTeam();
var member = (D.Member)team.Join(MemberName, false);
var master = team.ScrumMaster;
master.StartEstimation();
master.Estimation = new D.Estimation(1.0);
member.Estimation = new D.Estimation(2.0);
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
planningPoker.Setup(p => p.GetMessagesAsync(master, It.IsAny <CancellationToken>()))
.ReturnsAsync(() => master.Messages.ToList()).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = await target.GetMessages(TeamName, ScrumMasterName, 1, default(CancellationToken));
// Verify
planningPoker.Verify();
teamLock.Verify();
Assert.IsNotNull(result);
Assert.AreEqual <int>(4, result.Count);
Assert.AreEqual <long>(2, result[0].Id);
Assert.AreEqual <MessageType>(MessageType.EstimationStarted, result[0].Type);
Assert.AreEqual <long>(3, result[1].Id);
Assert.AreEqual <MessageType>(MessageType.MemberEstimated, result[1].Type);
Assert.AreEqual <long>(4, result[2].Id);
Assert.AreEqual <MessageType>(MessageType.MemberEstimated, result[2].Type);
Assert.AreEqual <long>(5, result[3].Id);
Assert.AreEqual <MessageType>(MessageType.EstimationEnded, result[3].Type);
Assert.IsInstanceOfType(result[3], typeof(EstimationResultMessage));
var estimationResultMessage = (EstimationResultMessage)result[3];
Assert.IsNotNull(estimationResultMessage.EstimationResult);
var expectedResult = new Tuple <string, double>[]
{
new Tuple <string, double>(ScrumMasterName, 1.0),
new Tuple <string, double>(MemberName, 2.0)
};
CollectionAssert.AreEquivalent(expectedResult, estimationResultMessage.EstimationResult.Select(i => new Tuple <string, double>(i.Member.Name, i.Estimation.Value.Value)).ToList());
}
public void ReconnectTeam_TeamNameAndNonExistingMemberName_ArgumentException()
{
// Arrange
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = target.ReconnectTeam(TeamName, MemberName);
// Verify
Assert.IsInstanceOfType(result.Result, typeof(BadRequestObjectResult));
}
public void JoinTeam_TeamNameAndObserverNameAsObserver_ObserverIsAddedToTheTeam()
{
// Arrange
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.JoinTeam(TeamName, ObserverName, true);
// Verify
var expectedObservers = new string[] { ObserverName };
CollectionAssert.AreEquivalent(expectedObservers, team.Observers.Select(m => m.Name).ToList());
}
public void JoinTeam_TeamNameAndMemberNameAsMemberAndEstimationStarted_ScrumMasterIsEstimationParticipant()
{
// Arrange
var team = CreateBasicTeam();
team.ScrumMaster.StartEstimation();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.JoinTeam(TeamName, MemberName, false);
// Verify
var expectedParticipants = new string[] { ScrumMasterName };
CollectionAssert.AreEquivalent(expectedParticipants, team.EstimationParticipants.Select(m => m.MemberName).ToList());
}
public void StartEstimation_TeamName_ScrumTeamEstimationIsInProgress()
{
// Arrange
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.StartEstimation(TeamName);
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.AreEqual <D.TeamState>(D.TeamState.EstimationInProgress, team.State);
}
public void SubmitEstimation_TeamNameAndScrumMasterNameAndMinus1111111_EstimationIsSetToNull()
{
// Arrange
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.SubmitEstimation(TeamName, ScrumMasterName, -1111111.0);
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNotNull(team.ScrumMaster.Estimation);
Assert.IsNull(team.ScrumMaster.Estimation.Value);
}
public async Task GetMessages_NoMessagesOnTime_ReturnsEmptyCollection()
{
// Arrange
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
planningPoker.Setup(p => p.GetMessagesAsync(team.ScrumMaster, It.IsAny <CancellationToken>()))
.ReturnsAsync(Enumerable.Empty <D.Message>()).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = await target.GetMessages(TeamName, ScrumMasterName, 0, default(CancellationToken));
// Verify
planningPoker.Verify();
Assert.IsNotNull(result);
Assert.AreEqual <int>(0, result.Count);
}
public void DisconnectTeam_TeamNameAndScrumMasterName_ScrumMasterIsRemovedFromTheTeam()
{
// Arrange
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.DisconnectTeam(TeamName, ScrumMasterName);
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNull(team.ScrumMaster);
Assert.IsFalse(team.Members.Any());
}
public async Task GetMessages_NoMessagesOnTime_ReturnsEmptyCollection()
{
// Arrange
var team = CreateBasicTeam();
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
planningPoker.Setup(p => p.GetMessagesAsync(team.ScrumMaster, It.IsAny <Action <bool, D.Observer> >()))
.Callback <D.Observer, Action <bool, D.Observer> >((o, c) => c(false, null)).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
var result = await target.GetMessages(TeamName, ScrumMasterName, 0);
// Verify
planningPoker.Verify();
Assert.IsNotNull(result);
Assert.AreEqual <int>(0, result.Count);
}
public void SubmitEstimation_TeamNameAndMemberNameAndMinus1111100_EstimationOfMemberIsSetToInfinity()
{
// Arrange
var team = CreateBasicTeam();
var member = (D.Member)team.Join(MemberName, false);
var teamLock = CreateTeamLock(team);
var planningPoker = new Mock <D.IPlanningPoker>(MockBehavior.Strict);
planningPoker.Setup(p => p.GetScrumTeam(TeamName)).Returns(teamLock.Object).Verifiable();
var target = new PlanningPokerService(planningPoker.Object);
// Act
target.SubmitEstimation(TeamName, MemberName, -1111100.0);
// Verify
planningPoker.Verify();
teamLock.Verify();
teamLock.Verify(l => l.Team);
Assert.IsNotNull(member.Estimation);
Assert.IsTrue(double.IsPositiveInfinity(member.Estimation.Value.Value));
}
