public void AddAttendee_WhenMemberIsNotAttendeeAndChangedDecision_IsSuccessful()
{
var creatorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions
{
CreatorId = creatorId
});
var newMemberId = new MemberId(Guid.NewGuid());
meetingTestData.MeetingGroup.JoinToGroupMember(newMemberId);
meetingTestData.Meeting.AddNotAttendee(newMemberId);
meetingTestData.Meeting.AddAttendee(meetingTestData.MeetingGroup, newMemberId, 0);
var meetingNotAttendeeChangedDecision = AssertPublishedDomainEvent <MeetingNotAttendeeChangedDecisionDomainEvent>(meetingTestData.Meeting);
Assert.That(meetingNotAttendeeChangedDecision.MemberId, Is.EqualTo(newMemberId));
}
private Meeting(
MeetingGroupId meetingGroupId,
string title,
MeetingTerm term,
string description,
MeetingLocation location,
MeetingLimits meetingLimits,
Term rsvpTerm,
MoneyValue eventFee,
List <MemberId> hostsMembersIds,
MemberId creatorId)
{
Id = new MeetingId(Guid.NewGuid());
_meetingGroupId = meetingGroupId;
_title = title;
_term = term;
_description = description;
_location = location;
_meetingLimits = meetingLimits;
this.SetRsvpTerm(rsvpTerm, _term);
_eventFee = eventFee;
_creatorId = creatorId;
_createDate = SystemClock.Now;
_attendees = new List <MeetingAttendee>();
_notAttendees = new List <MeetingNotAttendee>();
_waitlistMembers = new List <MeetingWaitlistMember>();
this.AddDomainEvent(new MeetingCreatedDomainEvent(this.Id));
var rsvpDate = SystemClock.Now;
if (hostsMembersIds.Any())
{
foreach (var hostMemberId in hostsMembersIds)
{
_attendees.Add(MeetingAttendee.CreateNew(this.Id, hostMemberId, rsvpDate, MeetingAttendeeRole.Host, 0, MoneyValue.Undefined));
}
}
else
{
_attendees.Add(MeetingAttendee.CreateNew(this.Id, creatorId, rsvpDate, MeetingAttendeeRole.Host, 0, MoneyValue.Undefined));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void filtersSelf() throws org.neo4j.causalclustering.upstream.UpstreamDatabaseSelectionException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void FiltersSelf()
{
// given
MemberId myself = new MemberId(new System.Guid(1234, 5678));
Config config = Config.defaults();
string groupName = "groupName";
// and
ConnectToRandomCoreServerStrategy connectToRandomCoreServerStrategy = new ConnectToRandomCoreServerStrategy();
connectToRandomCoreServerStrategy.Inject(new TopologyServiceThatPrioritisesItself(myself, groupName), config, NullLogProvider.Instance, myself);
// when
Optional <MemberId> found = connectToRandomCoreServerStrategy.UpstreamDatabase();
// then
Assert.assertTrue(found.Present);
Assert.assertNotEquals(myself, found);
}
public void SetAttendeeRole_WhenMemberIsOrganizer_IsSuccessful()
{
var creatorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions
{
CreatorId = creatorId
});
var newOrganizerId = new MemberId(Guid.NewGuid());
meetingTestData.MeetingGroup.JoinToGroupMember(newOrganizerId);
meetingTestData.Meeting.AddAttendee(meetingTestData.MeetingGroup, newOrganizerId, 0);
meetingTestData.Meeting.SetHostRole(meetingTestData.MeetingGroup, creatorId, newOrganizerId);
meetingTestData.Meeting.SetAttendeeRole(meetingTestData.MeetingGroup, creatorId, newOrganizerId);
var newMeetingHostSet = AssertPublishedDomainEvent <MemberSetAsAttendeeDomainEvent>(meetingTestData.Meeting);
Assert.That(newMeetingHostSet.HostId, Is.EqualTo(newOrganizerId));
}
// todo: add this to metrics tracking
public async Task AddGroupsToMember(MemberId member, IReadOnlyCollection <GroupId> groups)
{
await using var conn = await _db.Obtain();
await using var w =
conn.BeginBinaryImport("copy group_members (group_id, member_id) from stdin (format binary)");
foreach (var group in groups)
{
await w.StartRowAsync();
await w.WriteAsync(group.Value);
await w.WriteAsync(member.Value);
}
await w.CompleteAsync();
_logger.Information("Added member {MemberId} to groups {GroupIds}", member, groups);
}
public static async Task <MeetingGroupMemberData> GetMeetingGroupMember(MemberId memberId, MeetingId meetingOfGroupId, IDbConnection connection)
{
var result = await connection.QuerySingleAsync <MeetingGroupMemberResponse>(
"SELECT " +
$"[MeetingGroupMember].{nameof(MeetingGroupMemberResponse.MeetingGroupId)}, " +
$"[MeetingGroupMember].{nameof(MeetingGroupMemberResponse.MemberId)} " +
"FROM [meetings].[v_MeetingGroupMembers] AS [MeetingGroupMember] " +
"INNER JOIN [meetings].[Meetings] AS [Meeting] ON [Meeting].[MeetingGroupId] = [MeetingGroupMember].[MeetingGroupId] " +
"WHERE [MeetingGroupMember].[MemberId] = @MemberId AND [Meeting].[Id] = @MeetingId",
new
{
MemberId = memberId.Value,
MeetingId = meetingOfGroupId.Value
});
return(new MeetingGroupMemberData(
new MeetingGroupId(result.MeetingGroupId),
new MemberId(result.MemberId)));
}
public void OnDeserialization(XmlNode objectNode)
{
_xmlNode = objectNode;
if (_id == 0)
{
XmlNode idNode = _xmlNode.OwnerDocument.CreateElement(XmlTags.XML_PROPERTY);
XmlUtil.SetNameAttribute(idNode, "MemberId");
_xmlNode.AppendChild(idNode);
idNode.InnerText = MemberId.ToString(System.Globalization.CultureInfo.InvariantCulture);
}
XmlNodeList nl = _xmlNode.SelectNodes(string.Format(System.Globalization.CultureInfo.InvariantCulture,
"{0}/{1}",
XML_VALUES, XmlTags.XML_Item));
foreach (XmlNode nd in nl)
{
SetResourceString(XmlUtil.GetNameAttribute(nd), nd.InnerText);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void ignoresSelf() throws org.neo4j.causalclustering.upstream.UpstreamDatabaseSelectionException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void IgnoresSelf()
{
// given
MemberId myself = new MemberId(new System.Guid(1234, 5678));
string groupName = "groupName";
// and
LeaderOnlyStrategy leaderOnlyStrategy = new LeaderOnlyStrategy();
TopologyServiceThatPrioritisesItself topologyServiceNoRetriesStrategy = new TopologyServiceThatPrioritisesItselfAnonymousInnerClass(this, myself, groupName);
leaderOnlyStrategy.Inject(topologyServiceNoRetriesStrategy, Config.defaults(), NullLogProvider.Instance, myself);
// when
Optional <MemberId> resolved = leaderOnlyStrategy.UpstreamDatabase();
// then
Assert.assertTrue(resolved.Present);
Assert.assertNotEquals(myself, resolved.get());
}
private void DownloadDatabase(StoreId localStoreId)
{
try
{
_localDatabase.stopForStoreCopy();
_enableDisableOnStoreCopy.disable();
}
catch (Exception throwable)
{
throw new Exception(throwable);
}
try
{
MemberId source = _selectionStrategy.bestUpstreamDatabase();
AdvertisedSocketAddress fromAddress = _topologyService.findCatchupAddress(source).orElseThrow(() => new TopologyLookupException(source));
_storeCopyProcess.replaceWithStoreFrom(new CatchupAddressProvider_SingleAddressProvider(fromAddress), localStoreId);
}
catch (Exception e) when(e is IOException || e is StoreCopyFailedException || e is UpstreamDatabaseSelectionException || e is TopologyLookupException)
{
_log.warn("Error copying store. Will retry shortly.", e);
return;
}
catch (DatabaseShutdownException e)
{
_log.warn("Store copy aborted due to shutdown.", e);
return;
}
try
{
_localDatabase.start();
_enableDisableOnStoreCopy.enable();
}
catch (Exception throwable)
{
throw new Exception(throwable);
}
_latestTxIdOfUpStream = 0; // we will find out on the next pull request response
_state = TX_PULLING;
_applier.refreshFromNewStore();
}
public void AddComment_WhenDataIsValid_IsSuccessful()
{
// Arrange
var commentAuthorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions {
Attendees = new[] { commentAuthorId }
});
var comment = "Great meeting!";
// Act
var meetingComment = meetingTestData.Meeting.AddComment(commentAuthorId, comment, meetingTestData.MeetingGroup, meetingTestData.MeetingCommentingConfiguration);
// Assert
var meetingCommentCreatedEvent = AssertPublishedDomainEvent <MeetingCommentAddedDomainEvent>(meetingComment);
Assert.That(meetingCommentCreatedEvent.MeetingCommentId, Is.EqualTo(meetingComment.Id));
Assert.That(meetingCommentCreatedEvent.MeetingId, Is.EqualTo(meetingTestData.Meeting.Id));
Assert.That(meetingCommentCreatedEvent.Comment, Is.EqualTo(comment));
}
public void EditComment_WhenNewTextIsEmpty_BreaksCommentTextMustBeProvidedRule(string missingComment)
{
// Arrange
var authorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions {
Attendees = new[] { authorId }
});
var meetingComment = meetingTestData.Meeting.AddComment(authorId, "Great meeting!", meetingTestData.MeetingCommentingConfiguration);
meetingComment.ClearDomainEvents();
// Assert
AssertBrokenRule <CommentTextMustBeProvidedRule>(() =>
{
// Act
meetingComment.Edit(new MemberId(Guid.NewGuid()), missingComment, meetingTestData.MeetingCommentingConfiguration);
});
}
private MeetingComment(MeetingId meetingId, MemberId authorId, string comment, MeetingCommentId?inReplyToCommentId)
{
this.CheckRule(new CommentTextMustBeProvidedRule(comment));
this.Id = new MeetingCommentId(Guid.NewGuid());
_meetingId = meetingId;
_authorId = authorId;
_comment = comment;
_inReplyToCommentId = inReplyToCommentId;
_createDate = SystemClock.Now;
_editDate = null;
_isRemoved = false;
_removedByReason = null;
this.AddDomainEvent(new MeetingCommentCreatedDomainEvent(Id));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void leaderShouldNotRespondToSuccessResponseThatIndicatesUpToDateFollower() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void LeaderShouldNotRespondToSuccessResponseThatIndicatesUpToDateFollower()
{
// given
/*
* A leader who
* - has an append index of 100
* - knows about instance 2
* - assumes that instance 2 is at an index less than 100 -say 84
*/
Leader leader = new Leader();
MemberId instance2 = member(2);
FollowerState instance2State = CreateArtificialFollowerState(84);
ReadableRaftState state = mock(typeof(ReadableRaftState));
FollowerStates <MemberId> followerState = new FollowerStates <MemberId>();
followerState = new FollowerStates <MemberId>(followerState, instance2, instance2State);
ReadableRaftLog logMock = mock(typeof(ReadableRaftLog));
when(logMock.AppendIndex()).thenReturn(100L);
when(state.CommitIndex()).thenReturn(-1L);
when(state.EntryLog()).thenReturn(logMock);
when(state.FollowerStates()).thenReturn(followerState);
when(state.Term()).thenReturn(4L); // both leader and follower are in the same term
// when
// that leader is asked to handle a response from that follower that says that the follower is up to date
Org.Neo4j.causalclustering.core.consensus.RaftMessages_AppendEntries_Response response = appendEntriesResponse().success().matchIndex(100).term(4).from(instance2).build();
Outcome outcome = leader.Handle(response, state, mock(typeof(Log)));
// then
// The leader should not be trying to send any messages to that instance
assertTrue(outcome.OutgoingMessages.Count == 0);
// And the follower state should be updated
FollowerStates <MemberId> updatedFollowerStates = outcome.FollowerStates;
assertEquals(100, updatedFollowerStates.Get(instance2).MatchIndex);
}
public void SetHostRole_WhenSettingMemberIsNotAOrganizerOrHostMeeting_IsNotPossible()
{
var creatorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions
{
CreatorId = creatorId
});
var settingMemberId = new MemberId(Guid.NewGuid());
var newOrganizerId = new MemberId(Guid.NewGuid());
meetingTestData.MeetingGroup.JoinToGroupMember(newOrganizerId);
meetingTestData.MeetingGroup.JoinToGroupMember(settingMemberId);
meetingTestData.Meeting.AddAttendee(meetingTestData.MeetingGroup, newOrganizerId, 0);
AssertBrokenRule <OnlyMeetingOrGroupOrganizerCanSetMeetingMemberRolesRule>(() =>
{
meetingTestData.Meeting.SetHostRole(meetingTestData.MeetingGroup, settingMemberId, newOrganizerId);
});
}
public void DisableCommenting_WhenCommentingAlreadyDisabled_IsIgnored()
{
// Arrange
var organizerId = new MemberId(Guid.NewGuid());
var meeting = CreateMeetingTestData(new MeetingTestDataOptions {
CreatorId = organizerId
});
var meetingCommentingConfiguration = meeting.Meeting.CreateCommentingConfiguration();
meetingCommentingConfiguration.DisableCommenting(organizerId, meeting.MeetingGroup);
meetingCommentingConfiguration.ClearDomainEvents();
// Act
meetingCommentingConfiguration.DisableCommenting(organizerId, meeting.MeetingGroup);
// Assert
AssertDomainEventNotPublished <MeetingCommentingDisabledDomainEvent>(meetingCommentingConfiguration);
}
void ParseIdentifier()
{
Token token = this.PeekToken();
if (!Parser.IsCanFollowIdentifier(token))
{
throw this.BuildException(Error.BinaryCommaMemberParenIndexerExpected);
}
if (this._tree._top.Expression is MemberOp)
{
MemberId memberId = new MemberId(this._current.StringValue);
_tree.AddOperand(memberId);
}
else
{
Variable variable = new Variable(this._current.StringValue);
_tree.AddOperand(variable);
}
}
public void DisableCommenting_IsSuccessfull()
{
// Arrange
var organizerId = new MemberId(Guid.NewGuid());
var meeting = CreateMeetingTestData(new MeetingTestDataOptions {
CreatorId = organizerId
});
var meetingCommentingConfiguration = meeting.Meeting.CreateCommentingConfiguration();
meetingCommentingConfiguration.ClearDomainEvents();
// Act
meetingCommentingConfiguration.DisableCommenting(organizerId, meeting.MeetingGroup);
// Assert
var meetingCommentingDisabledEvent = AssertPublishedDomainEvent <MeetingCommentingDisabledDomainEvent>(meetingCommentingConfiguration);
Assert.That(meetingCommentingDisabledEvent.MeetingId, Is.EqualTo(meeting.Meeting.Id));
}
public void CreateMeetingGroup_IsSuccessful_And_CreatorIsAHost()
{
var proposalMemberId = new MemberId(Guid.NewGuid());
var name = "name";
var description = "description";
var meetingGroupLocation = MeetingGroupLocation.CreateNew("Warsaw", "PL");
var meetingProposal = MeetingGroupProposal.ProposeNew(
name, description,
meetingGroupLocation, proposalMemberId);
var meetingGroup = meetingProposal.CreateMeetingGroup();
var meetingGroupCreated = AssertPublishedDomainEvent <MeetingGroupCreatedDomainEvent>(meetingGroup);
var newMeetingGroupMemberJoined = AssertPublishedDomainEvent <NewMeetingGroupMemberJoinedDomainEvent>(meetingGroup);
Assert.That(meetingGroupCreated.MeetingGroupId, Is.EqualTo(meetingProposal.Id));
Assert.That(newMeetingGroupMemberJoined.MemberId, Is.EqualTo(proposalMemberId));
Assert.That(newMeetingGroupMemberJoined.Role, Is.EqualTo(MeetingGroupMemberRole.Organizer));
}
public void SignOffMemberFromWaitList_WhenMemberIsOnWaitList_IsSuccessful()
{
var creatorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions
{
CreatorId = creatorId
});
var memberId = new MemberId(Guid.NewGuid());
meetingTestData.MeetingGroup.JoinToGroupMember(memberId);
meetingTestData.Meeting.SignUpMemberToWaitlist(meetingTestData.MeetingGroup, memberId);
meetingTestData.Meeting.SignOffMemberFromWaitlist(memberId);
var memberSignedOffFromMeetingWaitlist = AssertPublishedDomainEvent <MemberSignedOffFromMeetingWaitlistDomainEvent>(meetingTestData.Meeting);
Assert.That(memberSignedOffFromMeetingWaitlist.MemberId, Is.EqualTo(memberId));
}
public void CancelMeeting_WhenMeetingHasNotStarted_IsSuccessful()
{
var creatorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions
{
CreatorId = creatorId
});
var date = DateTime.UtcNow;
SystemClock.Set(date);
meetingTestData.Meeting.Cancel(creatorId);
var meetingCanceled = AssertPublishedDomainEvent <MeetingCanceledDomainEvent>(meetingTestData.Meeting);
Assert.That(meetingCanceled.MeetingId, Is.EqualTo(meetingTestData.Meeting.Id));
Assert.That(meetingCanceled.CancelMemberId, Is.EqualTo(creatorId));
Assert.That(meetingCanceled.CancelDate, Is.EqualTo(date));
}
public void RemoveComment_ByAuthor_BreaksRemovingReasonCanBeProvidedOnlyByGroupOrganizer()
{
// Arrange
var commentAuthorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions {
Attendees = new[] { commentAuthorId }
});
var meetingComment = meetingTestData.Meeting.AddComment(commentAuthorId, "Great meeting!");
meetingComment.ClearDomainEvents();
// Assert
AssertBrokenRule <RemovingReasonCanBeProvidedOnlyByGroupOrganizer>(() =>
{
// Act
meetingComment.Remove(removingMemberId: commentAuthorId, meetingTestData.MeetingGroup, "I don't like the comment.");
});
}
private bool PullAndApplyBatchOfTransactions(MemberId upstream, StoreId localStoreId, int batchCount)
{
long lastQueuedTxId = _applier.lastQueuedTxId();
_pullRequestMonitor.txPullRequest(lastQueuedTxId);
TxPullRequest txPullRequest = new TxPullRequest(lastQueuedTxId, localStoreId);
_log.debug("Pull transactions from %s where tx id > %d [batch #%d]", upstream, lastQueuedTxId, batchCount);
TxStreamFinishedResponse response;
try
{
AdvertisedSocketAddress fromAddress = _topologyService.findCatchupAddress(upstream).orElseThrow(() => new TopologyLookupException(upstream));
response = _catchUpClient.makeBlockingRequest(fromAddress, txPullRequest, new CatchUpResponseAdaptorAnonymousInnerClass(this, response));
}
catch (Exception e) when(e is CatchUpClientException || e is TopologyLookupException)
{
_log.warn("Exception occurred while pulling transactions. Will retry shortly.", e);
StreamComplete();
return(false);
}
_latestTxIdOfUpStream = response.LatestTxId();
switch (response.Status())
{
case SUCCESS_END_OF_STREAM:
_log.debug("Successfully pulled transactions from tx id %d", lastQueuedTxId);
_upToDateFuture.complete(true);
return(false);
case E_TRANSACTION_PRUNED:
_log.info("Tx pull unable to get transactions starting from %d since transactions have been pruned. Attempting a store copy.", lastQueuedTxId);
_state = STORE_COPYING;
return(false);
default:
_log.info("Tx pull request unable to get transactions > %d " + lastQueuedTxId);
return(false);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void randomCoreDoesNotReturnSameCoreTwice()
public virtual void RandomCoreDoesNotReturnSameCoreTwice()
{
// given counter always core member
TypicallyConnectToRandomReadReplicaStrategy connectionStrategy = new TypicallyConnectToRandomReadReplicaStrategy(1);
// and
MemberId firstOther = new MemberId(new System.Guid(12, 34));
MemberId secondOther = new MemberId(new System.Guid(56, 78));
TopologyService topologyService = fakeTopologyService(fakeCoreTopology(Myself, firstOther, secondOther), fakeReadReplicaTopology(memberIDs(2)));
connectionStrategy.Inject(topologyService, Config.defaults(), NullLogProvider.Instance, Myself);
// when we collect enough results to feel confident of random values
IList <MemberId> found = IntStream.range(0, 20).mapToObj(i => connectionStrategy.UpstreamDatabase()).filter(Optional.isPresent).map(Optional.get).collect(Collectors.toList());
// then
assertFalse(found.Contains(Myself));
assertTrue(found.Contains(firstOther));
assertTrue(found.Contains(secondOther));
}
public async Task DoesNotRemoveIfIdDoesNotMatch()
{
var timeout = new CancellationTokenSource(1000).Token;
var(activator, identity, pid) = await GetActivatedClusterIdentity(timeout);
var differentPid = Activate(activator, identity);
var activation = await _storage.TryGetExistingActivation(identity, timeout);
await _storage.RemoveActivation(identity, differentPid, timeout);
var afterRemoval = await _storage.TryGetExistingActivation(identity, timeout);
activation.Should().NotBeNull();
activation !.MemberId.Should().Be(activator.Id);
activation !.Pid.Should().BeEquivalentTo(pid);
afterRemoval.Should().NotBeNull("Removal pid did not match id, even if it matched cluster identity");
}
public void AddAttendee_WhenMemberIsAlreadyAttendeeOfMeeting_IsNotPossible()
{
// Arrange
var creatorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions
{
CreatorId = creatorId
});
var newMemberId = new MemberId(Guid.NewGuid());
meetingTestData.MeetingGroup.JoinToGroupMember(newMemberId);
meetingTestData.Meeting.AddAttendee(meetingTestData.MeetingGroup, newMemberId, 0);
// Assert
AssertBrokenRule <MemberCannotBeAnAttendeeOfMeetingMoreThanOnceRule>(() =>
{
// Act
meetingTestData.Meeting.AddAttendee(meetingTestData.MeetingGroup, newMemberId, 0);
});
}
public void AddLikeToComment_WhenLikerIsNotGroupMember_BreaksCommentCanBeLikedOnlyByMeetingGroupMemberRule()
{
// Arrange
var commentAuthorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions {
Attendees = new[] { commentAuthorId }
});
var meetingComment = meetingTestData.Meeting.AddComment(commentAuthorId, "Great meeting!", meetingTestData.MeetingGroup, meetingTestData.MeetingCommentingConfiguration);
// Assert
AssertBrokenRule <CommentCanBeLikedOnlyByMeetingGroupMemberRule>(() =>
{
// Act
meetingComment.Like(
likerId: new MemberId(Guid.NewGuid()),
likerMeetingGroupMember: null,
meetingMemberCommentLikesCount: 0);
});
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldDefaultToRandomCoreServerIfNoOtherStrategySpecified() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldDefaultToRandomCoreServerIfNoOtherStrategySpecified()
{
// given
TopologyService topologyService = mock(typeof(TopologyService));
MemberId memberId = new MemberId(System.Guid.randomUUID());
when(topologyService.LocalCoreServers()).thenReturn(new CoreTopology(new ClusterId(System.Guid.randomUUID()), false, MapOf(memberId, mock(typeof(CoreServerInfo)))));
ConnectToRandomCoreServerStrategy defaultStrategy = new ConnectToRandomCoreServerStrategy();
defaultStrategy.Inject(topologyService, Config.defaults(), NullLogProvider.Instance, null);
UpstreamDatabaseStrategySelector selector = new UpstreamDatabaseStrategySelector(defaultStrategy);
// when
MemberId instance = selector.BestUpstreamDatabase();
// then
assertEquals(memberId, instance);
}
public void EditComment_ByNoAuthor_BreaksMeetingCommentCanBeEditedOnlyByAuthor()
{
// Arrange
var commentAuthorId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions {
Attendees = new[] { commentAuthorId }
});
var meetingComment = meetingTestData.Meeting.AddComment(commentAuthorId, "Great meeting!", meetingTestData.MeetingCommentingConfiguration);
meetingComment.ClearDomainEvents();
var editedComment = "Wonderful!";
// Assert
AssertBrokenRule <MeetingCommentCanBeEditedOnlyByAuthorRule>(() =>
{
// Act
meetingComment.Edit(new MemberId(Guid.NewGuid()), editedComment, meetingTestData.MeetingCommentingConfiguration);
});
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: void dump() throws java.io.IOException
internal virtual void Dump()
{
SimpleStorage <MemberId> memberIdStorage = new SimpleFileStorage <MemberId>(_fs, _clusterStateDirectory, CORE_MEMBER_ID_NAME, new MemberId.Marshal(), NullLogProvider.Instance);
if (memberIdStorage.Exists())
{
MemberId memberId = memberIdStorage.ReadState();
@out.println(CORE_MEMBER_ID_NAME + ": " + memberId);
}
DumpState(LAST_FLUSHED_NAME, new LongIndexMarshal());
DumpState(LOCK_TOKEN_NAME, new ReplicatedLockTokenState.Marshal(new MemberId.Marshal()));
DumpState(ID_ALLOCATION_NAME, new IdAllocationState.Marshal());
DumpState(SESSION_TRACKER_NAME, new GlobalSessionTrackerState.Marshal(new MemberId.Marshal()));
/* raft state */
DumpState(RAFT_MEMBERSHIP_NAME, new RaftMembershipState.Marshal());
DumpState(RAFT_TERM_NAME, new TermState.Marshal());
DumpState(RAFT_VOTE_NAME, new VoteState.Marshal(new MemberId.Marshal()));
}
public void RemoveComment_IsSuccessful()
{
// Arrange
var removingMemberId = new MemberId(Guid.NewGuid());
var meetingTestData = CreateMeetingTestData(new MeetingTestDataOptions {
Attendees = new[] { removingMemberId }
});
var meetingComment = meetingTestData.Meeting.AddComment(authorId: removingMemberId, "Great meeting!");
meetingComment.ClearDomainEvents();
// Act
meetingComment.Remove(removingMemberId, meetingTestData.MeetingGroup);
// Assert
var meetingCommentCreated = AssertPublishedDomainEvent <MeetingCommentRemovedDomainEvent>(meetingComment);
Assert.That(meetingCommentCreated.MeetingCommentId, Is.EqualTo(meetingComment.Id));
}
public void Scenario_AddAndRemoveMember()
{
var member = new MemberId(Constants.MeId);
_trelloReadWrite.Boards.AddMember(_welcomeBoardWritable, member);
var membersAfterAddMember = _trelloReadWrite.Members.ForBoard(_welcomeBoardWritable);
_trelloReadWrite.Boards.RemoveMember(_welcomeBoardWritable, member);
var membersAfterRemoveMember = _trelloReadWrite.Members.ForBoard(_welcomeBoardWritable);
Assert.That(membersAfterAddMember.Any(x => x.Id.Equals(Constants.MeId)));
Assert.That(!membersAfterRemoveMember.Any(x => x.Id.Equals(Constants.MeId)));
}
void ParseIdentifier() {
Token token = this.PeekToken();
if (!Parser.IsCanFollowIdentifier(token)) {
throw this.BuildException(Error.BinaryCommaMemberParenIndexerExpected);
}
if (this._tree._top.Expression is MemberOp) {
MemberId memberId = new MemberId(this._current.StringValue);
_tree.AddOperand(memberId);
} else {
Variable variable = new Variable(this._current.StringValue);
_tree.AddOperand(variable);
}
}
