public void PreventPlayersFromJoiningAPartyWithoutAValidInvite()
{
// Create a party.
var pitLeader = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
var partyId = _partyClient
.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitLeader }
}).PartyId;
// Verify that the party was successfully created.
var partyAssociatedToPlayer = _partyClient.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitLeader }
}).Party;
Assert.NotNull(partyAssociatedToPlayer);
// Verify that another player can successfully join the party.
var joinRequest = new JoinPartyRequest {
PartyId = partyId
};
var exception = Assert.Throws <RpcException>(() =>
_partyClient.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, CreatePlayerIdentityTokenForPlayer(PlayerId) }
}));
Assert.AreEqual(StatusCode.FailedPrecondition, exception.StatusCode);
Assert.That(exception.Message, Contains.Substring("not invited"));
}
public override Task <CreatePartyResponse> CreateParty(CreatePartyRequest request, ServerCallContext context)
{
var playerId = AuthHeaders.ExtractPlayerId(context);
var pit = AuthHeaders.ExtractPit(context);
// TODO(iuliaharasim/dom): Move logic specific to party creation in a separate class.
PartyDataModel party;
try
{
party = new PartyDataModel(playerId, pit, request.MinMembers, request.MaxMembers, request.Metadata);
}
catch (ArgumentException exception)
{
throw new RpcException(new Status(StatusCode.InvalidArgument, exception.Message));
}
var leader = party.GetLeader();
using (var memClient = _memoryStoreClientManager.GetClient())
using (var transaction = memClient.CreateTransaction())
{
transaction.CreateAll(new List <Entry> {
party, leader
});
}
return(Task.FromResult(new CreatePartyResponse {
PartyId = party.Id
}));
}
public Task <Party> CreateParty(CreatePartyRequest request)
{
var party = new Party
{
Name = "NullReferenceException",
Members = new List <PartyMember>()
};
party.Members.Add(new Fighter()
{
Id = 1,
Name = "Brambo",
Constitution = 11,
Strength = 12,
Intelligence = 11
});
party.Members.Add(new Fighter()
{
Id = 2,
Name = "Chrissy",
Constitution = 11,
Strength = 12,
Intelligence = 11
});
return(Task.FromResult(party));
}
public void CreateParty(CreatePartyRequest request)
{
var customer = _customerService.GetCustomer(request.CustomerId);
if (string.IsNullOrEmpty(customer.Phone.PhoneNumber))
{
throw new InvalidRequestException($"Customer {customer.Id} has not provided a phone number.");
}
if (!customer.Phone.IsVerified)
{
throw new InvalidRequestException($"Phone number for customer {customer.Id} has not been validated.");
}
var activeParty = GetParties(customer.Id, isActive: true);
if (activeParty.Any())
{
throw new InvalidRequestException($"Customer {customer.Id} has an existing active party");
}
var party = new Party(request);
_partyRepository.Add(party);
_partyRepository.Save();
}
public void PreventPlayersFromJoiningAPartyIfTheyAreMembersOfAnotherParty()
{
// Create a party.
var pitLeader = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
var partyId = _partyClient
.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitLeader }
}).PartyId;
// Verify that the party was successfully created.
var partyAssociatedToPlayer = _partyClient
.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitLeader }
})
.Party;
Assert.NotNull(partyAssociatedToPlayer);
// Create another party.
var pitAnotherPlayer = CreatePlayerIdentityTokenForPlayer(PlayerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = PlayerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
});
Assert.NotNull(inviteAnotherPlayer);
createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
_partyClient.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
});
// Verify that the party was successfully created.
partyAssociatedToPlayer = _partyClient
.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
})
.Party;
Assert.NotNull(partyAssociatedToPlayer);
// Verify that the second player is not allowed to join another party.
var joinRequest = new JoinPartyRequest {
PartyId = partyId
};
var exception = Assert.Throws <RpcException>(() =>
_partyClient.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
}));
Assert.AreEqual(StatusCode.AlreadyExists, exception.StatusCode);
}
public Party(CreatePartyRequest request)
{
CustomerId = request.CustomerId;
PartySize = request.PartySize;
CreatedDateTime = DateTime.Now;
IsNotified = false;
IsActive = true;
}
public void PreventNonLeadersFromKickingOutOtherMembers()
{
// Create a party.
var pitLeader = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
var partyId = _partyClient
.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitLeader }
}).PartyId;
// Another player joins the party.
var pitAnotherPlayer = CreatePlayerIdentityTokenForPlayer(PlayerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = PlayerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
});
Assert.NotNull(inviteAnotherPlayer);
var joinRequest = new JoinPartyRequest {
PartyId = partyId
};
_partyClient.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
});
// Verify that the player who has recently joined the party is associated to it.
var party = _partyClient.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
}).Party;
Assert.NotNull(party);
Assert.AreEqual(LeaderPlayerId, party.LeaderPlayerId);
// Verify that the leader can kick out other players.
_partyClient.KickOutPlayer(new KickOutPlayerRequest {
EvictedPlayerId = PlayerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
});
var exception = Assert.Throws <RpcException>(
() => _partyClient.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
}));
Assert.AreEqual(StatusCode.NotFound, exception.StatusCode);
}
public void ReturnPartyIdWhenSuccessful()
{
// Setup the client such that it will claim that TestLeader isn't a member of any party and such it will
// return a party id for some particular parameters.
IEnumerable <Entry> created = null;
_mockMemoryStoreClient.Setup(client => client.GetAsync <Member>(TestLeaderPlayerId))
.ReturnsAsync((Member)null);
_mockTransaction.Setup(tr => tr.CreateAll(It.IsAny <IEnumerable <Entry> >()))
.Callback <IEnumerable <Entry> >(entries => created = entries);
foreach (string AnalyticsEventType in AnalyticsEventTypes)
{
_mockAnalyticsSender.Setup(
sender => sender.Send(AnalyticsConstants.PartyClass, AnalyticsEventType,
It.Is <Dictionary <string, string> >(d => ExpectedAnalyticsDict(d)), TestLeaderPlayerId));
}
// Verify that a party has been successfully created and that its id has been returned.
var createPartyRequest = new CreatePartyRequest
{
MinMembers = TestMinMembers,
MaxMembers = TestMaxMembers
};
createPartyRequest.Metadata.Add(_testMetadata);
var context = Util.CreateFakeCallContext(TestLeaderPlayerId, Pit);
var createPartyResponse = _partyService.CreateParty(createPartyRequest, context).Result;
var entriesList = created.ToList();
Assert.AreEqual(2, entriesList.Count);
var party = (PartyDataModel)entriesList[0];
Assert.False(string.IsNullOrEmpty(party.Id));
Assert.AreEqual(TestLeaderPlayerId, party.LeaderPlayerId);
Assert.AreEqual(TestMinMembers, party.MinMembers);
Assert.AreEqual(TestMaxMembers, party.MaxMembers);
CollectionAssert.AreEquivalent(_testMetadata, party.Metadata);
Assert.That(party.MemberIdToPit, Contains.Key(TestLeaderPlayerId));
Assert.AreEqual(party.MemberIdToPit[TestLeaderPlayerId], Pit);
var leader = (Member)entriesList[1];
Assert.AreEqual(TestLeaderPlayerId, leader.Id);
Assert.AreEqual(party.Id, leader.PartyId);
Assert.AreEqual(party.Id, createPartyResponse.PartyId);
_mockAnalyticsSender.VerifyAll();
}
public void PreventNonLeadersFromDeletingAParty()
{
// Create a party.
var pitLeader = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
var partyId = _partyClient
.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitLeader }
}).PartyId;
// Verify that the party was successfully created.
var partyAssociatedToPlayer = _partyClient
.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitLeader }
})
.Party;
Assert.NotNull(partyAssociatedToPlayer);
// Another player joins the party.
var pitAnotherPlayer = CreatePlayerIdentityTokenForPlayer(PlayerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = PlayerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
});
Assert.NotNull(inviteAnotherPlayer);
var joinRequest = new JoinPartyRequest {
PartyId = partyId
};
_partyClient.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
});
// Verify that it is impossible for the non-leader to delete the party.
var exception = Assert.Throws <RpcException>(() =>
_partyClient.DeleteParty(new DeletePartyRequest(),
new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
}));
Assert.AreEqual(StatusCode.PermissionDenied, exception.StatusCode);
Assert.That(exception.Message, Contains.Substring("player needs to be the leader"));
}
public IActionResult CreateParty([FromBody] CreatePartyRequest request)
{
Authorize.TokenAgainstResource(HttpContext.User, request.CustomerId);
if (request.PartySize <= 0)
{
throw new InvalidRequestException("PartySize must be greater than 0.");
}
var domainRequest = request.ToDomain();
_partyService.CreateParty(domainRequest);
return(Ok());
}
public override Task <CreatePartyResponse> CreateParty(CreatePartyRequest request, ServerCallContext context)
{
var playerId = AuthHeaders.ExtractPlayerId(context);
var pit = AuthHeaders.ExtractPit(context);
// TODO(iuliaharasim/dom): Move logic specific to party creation in a separate class.
PartyDataModel party;
try
{
party = new PartyDataModel(playerId, pit, request.MinMembers, request.MaxMembers, request.Metadata);
}
catch (ArgumentException exception)
{
throw new RpcException(new Status(StatusCode.InvalidArgument, exception.Message));
}
var leader = party.GetLeader();
using (var memClient = _memoryStoreClientManager.GetClient())
using (var transaction = memClient.CreateTransaction())
{
transaction.CreateAll(new List <Entry> {
party, leader
});
}
var eventAttributes = new Dictionary <string, string>
{
{ "partyId", party.Id }
};
string[] eventTypes = { "player_created_party", "player_joined_party", "party_created" };
foreach (string eventType in eventTypes)
{
if (eventType == "party_created")
{
eventAttributes.Add("partyPhase", party.CurrentPhase.ToString());
}
_analytics.Send(eventType, eventAttributes, playerId);
}
return(Task.FromResult(new CreatePartyResponse {
PartyId = party.Id
}));
}
public async Task MyAdventure_CreateParty_Should_Create_Two_Party_Members()
{
// Arrange
var adventure = new MyAdventure();
var request = new CreatePartyRequest
{
MembersCount = 2
};
// Act
var response = await adventure.CreateParty(request);
// Assert
response.Name.Should().Be("My Party");
response.Members.Should().HaveCount(2);
response.Members.Should().Contain(x => x.Name == "Member 1");
response.Members.Should().Contain(x => x.Name == "Member 2");
}
public Task <Party> CreateParty(CreatePartyRequest request)
{
var party = new Party
{
Name = "DedSec",
Members = new List <PartyMember>()
};
for (var i = 0; i < request.MembersCount; i++)
{
party.Members.Add(new Fighter()
{
Id = i,
Name = $"Hacker {i + 1}",
Constitution = 11,
Strength = 12,
Intelligence = 11
});
}
return(Task.FromResult(party));
}
public void PreventNonLeadersFromExtractingLeaderPit()
{
// Create a party.
var pitLeader = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
var partyId = _partyClient
.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitLeader }
}).PartyId;
// Another player joins the party.
var pitAnotherPlayer = CreatePlayerIdentityTokenForPlayer(PlayerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = PlayerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
});
Assert.NotNull(inviteAnotherPlayer);
var joinRequest = new JoinPartyRequest {
PartyId = partyId
};
_partyClient.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
});
// Verify that the player who has recently joined the party is associated to it.
var party = _partyClient.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
}).Party;
Assert.NotNull(party);
Assert.AreEqual(LeaderPlayerId, party.LeaderPlayerId);
}
public Task <Party> CreateParty(CreatePartyRequest request)
{
var party = new Party
{
Name = "My Party",
Members = new List <PartyMember>()
};
for (var i = 0; i < request.MembersCount; i++)
{
party.Members.Add(new Fighter()
{
Id = i,
Name = $"Member {i + 1}",
Constitution = 8,
Strength = 8,
Intelligence = 18
});
}
Console.WriteLine("Amount Party members: " + request.MembersCount);
return(Task.FromResult(party));
}
public Task <Party> CreateParty(CreatePartyRequest request)
{
var party = new Party
{
Name = "My Party",
Members = new List <PartyMember>()
};
for (var i = 0; i < request.MembersCount; i++)
{
if (_random.Next(0, 10) > 5)
{
party.Members.Add(new Wizard()
{
Id = i,
Name = $"Wizard {i + 1}",
Constitution = 11,
Strength = 9,
Intelligence = 14
});
}
else
{
party.Members.Add(new Fighter()
{
Id = i,
Name = $"Fighter {i + 1}",
Constitution = 11,
Strength = 14,
Intelligence = 9
});
}
}
return(Task.FromResult(party));
}
public Task <Party> CreateParty(CreatePartyRequest request)
{
var party = new Party
{
Name = "Monke Hakkers",
Members = new List <PartyMember>()
};
for (var i = 0; i < request.MembersCount; i++)
{
if (i % 2 == 0)
{
party.Members.Add(new Wizard
{
Id = i,
Name = $"Monke Wizard {i + 1}",
Constitution = 13,
Strength = 8,
Intelligence = 13
});
}
else
{
party.Members.Add(new Fighter
{
Id = i,
Name = $"Monke Fighter {i + 1}",
Constitution = 13,
Strength = 13,
Intelligence = 8
});
}
}
_party = party;
return(Task.FromResult(party));
}
public void CreatePartyAndAssociateLeaderToIt()
{
// Create a party.
var pit = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
var partyId = _partyClient.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pit }
})
.PartyId;
// Verify that the party was appropriately stored and is associated to the player that created it.
var partyAssociatedToPlayer = _partyClient
.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(), new Metadata {
{ PitRequestHeaderName, pit }
})
.Party;
Assert.AreEqual(partyId, partyAssociatedToPlayer.Id);
Assert.AreEqual(LeaderPlayerId, partyAssociatedToPlayer.LeaderPlayerId);
Assert.AreEqual(MinMembers, partyAssociatedToPlayer.MinMembers);
Assert.AreEqual(MaxMembers, partyAssociatedToPlayer.MaxMembers);
}
public Task <Party> CreateParty(CreatePartyRequest request)
{
var party = new Party
{
Name = "Fellowship of the chickenwing",
Members = new List <PartyMember>()
};
for (var i = 0; i < request.MembersCount; i++)
{
if (i % 2 == 0)
{
party.Members.Add(new Fighter()
{
Id = i,
Name = $"FighterMan",
Constitution = 15,
Strength = 11,
Intelligence = 8
});
}
else
{
party.Members.Add(new Wizard()
{
Id = i,
Name = $"Tim the Enchanter",
Constitution = 11,
Strength = 8,
Intelligence = 15
});
}
}
return(Task.FromResult(party));
}
public void LetOtherMembersJoinAParty()
{
// Create a party.
var pitLeader = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
var partyId = _partyClient
.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitLeader }
}).PartyId;
// Verify that the party was successfully created.
var partyAssociatedToPlayer = _partyClient
.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitLeader }
})
.Party;
Assert.NotNull(partyAssociatedToPlayer);
// Verify that another player can successfully join the party.
var pitAnotherPlayer = CreatePlayerIdentityTokenForPlayer(PlayerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = PlayerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
}).InviteId;
Assert.NotNull(inviteAnotherPlayer);
var joinRequest = new JoinPartyRequest {
PartyId = partyId
};
var partyJoined = _partyClient
.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
}).Party;
Assert.AreEqual(2, partyJoined.MemberIds.Count);
// Rejoining the same party should be allowed but the number of players should remain the same.
partyJoined = _partyClient
.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
}).Party;
Assert.AreEqual(2, partyJoined.MemberIds.Count);
// Clean up.
_partyClient.DeleteParty(new DeletePartyRequest(), new Metadata {
{ PitRequestHeaderName, pitLeader }
});
// Verify that its former members are no longer associated to the party since it has been deleted.
var exception = Assert.Throws <RpcException>(() =>
_partyClient.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitLeader }
}));
Assert.AreEqual(StatusCode.NotFound, exception.StatusCode);
exception = Assert.Throws <RpcException>(() =>
_partyClient.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
}));
Assert.AreEqual(StatusCode.NotFound, exception.StatusCode);
}
public void PreventPlayersFromJoiningAPartyIfItIsAtFullCapacity()
{
// Create a party.
var pitLeader = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
var partyId = _partyClient
.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitLeader }
}).PartyId;
// Verify that the party was successfully created.
var partyAssociatedToPlayer = _partyClient
.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitLeader }
})
.Party;
Assert.NotNull(partyAssociatedToPlayer);
// Fill up the party such that it is at full capacity.
for (var i = 1; i < MaxMembers; i++)
{
var playerId = $"{PlayerId}:{i}";
var pit = CreatePlayerIdentityTokenForPlayer(playerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = playerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
});
Assert.NotNull(inviteAnotherPlayer);
var joinRequest = new JoinPartyRequest {
PartyId = partyId
};
_partyClient.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, pit }
});
}
// Verify that it is impossible for another player to join the party.
var extraPlayerPit = CreatePlayerIdentityTokenForPlayer(PlayerId);
var inviteExtraPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = PlayerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
});
Assert.NotNull(inviteExtraPlayer);
var extraJoinRequest = new JoinPartyRequest {
PartyId = partyId
};
var exception = Assert.Throws <RpcException>(() =>
_partyClient.JoinParty(extraJoinRequest, new Metadata {
{ PitRequestHeaderName, extraPlayerPit }
}));
Assert.AreEqual(StatusCode.FailedPrecondition, exception.StatusCode);
Assert.That(exception.Message, Contains.Substring("full capacity"));
}
public void AllowLeadersToAppointOtherPlayersAsLeader()
{
// Create a party.
var pitLeader = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
var partyId = _partyClient
.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitLeader }
}).PartyId;
// Another player joins the party.
var pitAnotherPlayer = CreatePlayerIdentityTokenForPlayer(PlayerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = PlayerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
});
Assert.NotNull(inviteAnotherPlayer);
var joinRequest = new JoinPartyRequest {
PartyId = partyId
};
_partyClient.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
});
var partyAssociatedToPlayer = _partyClient
.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitLeader }
})
.Party;
// Appoint the newly joined player as the leader of the party.
partyAssociatedToPlayer.LeaderPlayerId = PlayerId;
var updatedParty = _partyClient.UpdateParty(new UpdatePartyRequest {
UpdatedParty = partyAssociatedToPlayer
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
}).Party;
// Verify that only the leader player id has been updated.
Assert.AreEqual(PlayerId, updatedParty.LeaderPlayerId);
Assert.AreEqual(MinMembers, updatedParty.MinMembers);
Assert.AreEqual(MaxMembers, updatedParty.MaxMembers);
Assert.AreEqual(PartyPhaseProto.Forming, updatedParty.CurrentPhase);
CollectionAssert.AreEquivalent(createPartyRequest.Metadata, updatedParty.Metadata);
// Verify that the leader no longer has the necessary permissions to perform certain operations.
var exception = Assert.Throws <RpcException>(() =>
_partyClient.DeleteParty(new DeletePartyRequest(),
new Metadata {
{ PitRequestHeaderName, pitLeader }
}));
Assert.AreEqual(StatusCode.PermissionDenied, exception.StatusCode);
updatedParty.CurrentPhase = PartyPhaseProto.Matchmaking;
exception = Assert.Throws <RpcException>(() =>
_partyClient.UpdateParty(new UpdatePartyRequest {
UpdatedParty = updatedParty
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
}));
Assert.AreEqual(StatusCode.PermissionDenied, exception.StatusCode);
}
public CreatePartyViewModel()
{
CreatePartyRequest = new CreatePartyRequest();
}
public void RandomlyAssignAnotherLeaderWhenTheyLeaveTheParty()
{
// Create a party.
var pitLeader = CreatePlayerIdentityTokenForPlayer(LeaderPlayerId);
var metadata = new Dictionary <string, string> {
{ "random", "things" }
};
var createPartyRequest = new CreatePartyRequest {
MinMembers = MinMembers, MaxMembers = MaxMembers
};
createPartyRequest.Metadata.Add(metadata);
var partyId = _partyClient
.CreateParty(createPartyRequest, new Metadata {
{ PitRequestHeaderName, pitLeader }
}).PartyId;
// Another player joins the party.
var pitAnotherPlayer = CreatePlayerIdentityTokenForPlayer(PlayerId);
var inviteAnotherPlayer = _inviteClient.CreateInvite(new CreateInviteRequest {
ReceiverPlayerId = PlayerId
},
new Metadata {
{ PitRequestHeaderName, pitLeader }
});
Assert.NotNull(inviteAnotherPlayer);
var joinRequest = new JoinPartyRequest {
PartyId = partyId
};
_partyClient.JoinParty(joinRequest, new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
});
// The leader leaves the party.
_partyClient.LeaveParty(new LeavePartyRequest(), new Metadata {
{ PitRequestHeaderName, pitLeader }
});
// Verify that the former-leader is no longer associated to any party.
_partyClient.LeaveParty(new LeavePartyRequest(), new Metadata {
{ PitRequestHeaderName, pitLeader }
});
var exception = Assert.Throws <RpcException>(
() => _partyClient.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitLeader }
}));
Assert.AreEqual(StatusCode.NotFound, exception.StatusCode);
// Verify that the other remaining player has automatically been assigned the role of 'leader' since there
// are no other members in the party.
var partyAfterLeaderLeft = _partyClient
.GetPartyByPlayerId(new GetPartyByPlayerIdRequest(),
new Metadata {
{ PitRequestHeaderName, pitAnotherPlayer }
}).Party;
Assert.AreEqual(PlayerId, partyAfterLeaderLeft.LeaderPlayerId);
}
