public void AddRelatedTicket(int ticketID1, int ticketID2)
{
Ticket ticket1 = Tickets.GetTicket(UserSession.LoginUser, ticketID1);
Ticket ticket2 = Tickets.GetTicket(UserSession.LoginUser, ticketID2);
if (ticket1.ParentID == ticketID2 || ticket2.ParentID == ticketID1)
{
return;
}
if (ticketID1 == ticketID2)
{
return;
}
TicketRelationship item = TicketRelationships.GetTicketRelationship(UserSession.LoginUser, ticketID1, ticketID2);
if (item == null)
{
item = (new TicketRelationships(UserSession.LoginUser)).AddNewTicketRelationship();
item.OrganizationID = UserSession.LoginUser.OrganizationID;
item.Ticket1ID = ticketID1;
item.Ticket2ID = ticketID2;
item.Collection.Save();
}
}
public void Equals_returns_false_for_object([HasIdentity] TicketRelationship ticketRel,
[HasIdentity] DirectionalRelationship rel1)
{
var sut = new TraversibleRelationship(ticketRel.GetIdentity(), null, null, rel1.GetIdentity());
Assert.That(() => sut.Equals(new Object()), Is.False);
}
public void Edit_can_remove_two_secondary_relationships_which_are_unwanted(Ticket ticket,
EditTicketRequest request,
[HasIdentity] TicketRelationship firstRelationship,
[HasIdentity] TicketRelationship secondRelationship,
[HasIdentity] TicketRelationship thirdRelationship,
RelationshipRemovingTicketEditorDecorator sut)
{
// Arrange
ticket.SecondaryRelationships.Clear();
ticket.SecondaryRelationships.Add(firstRelationship);
ticket.SecondaryRelationships.Add(secondRelationship);
ticket.SecondaryRelationships.Add(thirdRelationship);
request.RelationshipsToRemove.Clear();
request.RelationshipsToRemove.Add(new DeleteRelationshipRequest {
TicketRelationshipId = firstRelationship.GetIdentity()
});
request.RelationshipsToRemove.Add(new DeleteRelationshipRequest {
TicketRelationshipId = secondRelationship.GetIdentity()
});
// Act
sut.Edit(ticket, request);
// Assert
Assert.That(ticket.SecondaryRelationships, Is.EquivalentTo(new [] { thirdRelationship }));
}
public void RemoveRelatedTicket(int ticketID1, int ticketID2)
{
TicketRelationship item = TicketRelationships.GetTicketRelationship(UserSession.LoginUser, ticketID1, ticketID2);
//if (item.CreatorID == UserSession.LoginUser.UserID || UserSession.CurrentUser.IsSystemAdmin)
{
item.Delete();
item.Collection.Save();
}
}
public void Equals_returns_true_for_two_equal_identities([HasIdentity] TicketRelationship ticketRel,
[HasIdentity] DirectionalRelationship rel1,
[HasIdentity] DirectionalRelationship rel2)
{
var sut = new TraversibleRelationship(ticketRel.GetIdentity(), null, null, rel1.GetIdentity());
var two = new TraversibleRelationship(ticketRel.GetIdentity(), null, null, rel2.GetIdentity());
Assert.That(() => sut.Equals(two), Is.True);
}
public override int GetHashCode()
{
var ticketRelationshipHash = (TicketRelationship?.GetHashCode()).GetValueOrDefault(19);
var primaryHash = (PrimaryTicket?.GetHashCode()).GetValueOrDefault(23);
var secondaryHash = (SecondaryTicket?.GetHashCode()).GetValueOrDefault(29);
var relationshipHash = (Relationship?.GetHashCode()).GetValueOrDefault(37);
var typeHash = Type.GetHashCode();
return(ticketRelationshipHash ^ primaryHash ^ secondaryHash ^ relationshipHash ^ typeHash);
}
public static string GetTicketRelationship(RestCommand command, int ticketRelationshipID)
{
TicketRelationship ticketRelationship = TicketRelationships.GetTicketRelationship(command.LoginUser, ticketRelationshipID);
if (ticketRelationship.OrganizationID != command.Organization.OrganizationID)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
return(ticketRelationship.GetXml("TicketRelationship", true));
}
TheoreticalRelationship MapToTheoreticalRelationship(TicketRelationship tr)
{
return(new TheoreticalRelationship {
PrimaryTicket = tr.PrimaryTicket.GetIdentity(),
SecondaryTicket = tr.SecondaryTicket.GetIdentity(),
TicketRelationship = tr.GetIdentity(),
Relationship = tr.Relationship,
Type = TheoreticalRelationshipType.Existing,
});
}
public void IsRelationshipCircular_returns_true_when_complex_circle_exists([HasIdentity] DirectionalRelationship rel,
[HasIdentity] Ticket ticket1,
[HasIdentity] Ticket ticket2,
[HasIdentity] Ticket ticket3,
[HasIdentity] Ticket ticket4,
[HasIdentity] Ticket ticket5,
[HasIdentity] TicketRelationship tr1,
[HasIdentity] TicketRelationship tr2,
[HasIdentity] TicketRelationship tr3,
[HasIdentity] TicketRelationship tr4,
[HasIdentity] TicketRelationship tr5,
CircularRelationshipDetector sut)
{
var traversibleRelationships = new[] {
new TraversibleRelationship(tr1.GetIdentity(),
ticket1.GetIdentity(),
ticket2.GetIdentity(),
rel.GetIdentity()),
new TraversibleRelationship(tr2.GetIdentity(),
ticket2.GetIdentity(),
ticket3.GetIdentity(),
rel.GetIdentity()),
new TraversibleRelationship(tr3.GetIdentity(),
ticket2.GetIdentity(),
ticket4.GetIdentity(),
rel.GetIdentity()),
new TraversibleRelationship(tr4.GetIdentity(),
ticket5.GetIdentity(),
ticket4.GetIdentity(),
rel.GetIdentity()),
new TraversibleRelationship(tr5.GetIdentity(),
ticket4.GetIdentity(),
ticket1.GetIdentity(),
rel.GetIdentity()),
};
var result = sut.IsRelationshipCircular(rel.GetIdentity(), traversibleRelationships);
Assert.That(result, Is.True);
}
public void Entity_should_persist_successfully([NoAutoProperties] TicketRelationship ticketRelationship,
DirectionalRelationship relationship,
Ticket primary,
Ticket secondary,
[FromDi] Lazy <ISessionFactory> sessionFactory,
[FromDi] Lazy <IResetsDatabase> dbResetter)
{
ticketRelationship.Relationship = relationship;
ticketRelationship.PrimaryTicket = primary;
ticketRelationship.SecondaryTicket = secondary;
using (var provider = new CachingDataConnectionFactoryAdapter(new CSF.ORM.NHibernate.SessionFactoryAdapter(sessionFactory.Value)))
{
var result = TestPersistence.UsingConnectionProvider(provider)
.WithSetup(s => dbResetter.Value.ResetDatabase(), false)
.WithEntity(ticketRelationship)
.WithEqualityRule(builder => {
return(builder
.ForAllOtherProperties());
});
Assert.That(result, Persisted.Successfully());
}
}
TicketRelationshipDto GetRelationship(TicketRelationship relationship,
RelationshipParticipant participant,
IGetsRelationshipSummary summaryProvider,
ResolutionContext ctx)
{
Ticket relatedTicket;
if (participant == RelationshipParticipant.Primary)
{
relatedTicket = relationship.SecondaryTicket;
}
else
{
relatedTicket = relationship.PrimaryTicket;
}
return(new TicketRelationshipDto {
Id = relationship.GetIdentity(),
RelationshipId = relationship.Relationship?.GetIdentity(),
Summary = summaryProvider.GetSummary(relationship.Relationship, participant),
Participant = participant,
RelatedTicket = ctx.Mapper.Map <TicketSummaryDto>(relatedTicket),
});
}
public void GetRelationships_can_get_a_grandchild_relationship(Ticket ticket1,
Ticket ticket2,
Ticket ticket3,
DirectionalRelationship relationship)
{
var rel1 = new TicketRelationship {
PrimaryTicket = ticket1,
SecondaryTicket = ticket2,
Relationship = relationship
};
var rel2 = new TicketRelationship {
PrimaryTicket = ticket2,
SecondaryTicket = ticket3,
Relationship = relationship
};
var result = ExerciseSut(ticket1, rel1, rel2);
Assert.That(result?.Count, Is.EqualTo(2), "Count of results");
Assert.That(result?.Select(x => x?.Ticket)?.ToList(), Is.EquivalentTo(new[] { ticket1, ticket1 }), "Correct source tickets");
Assert.That(result?.Select(x => x?.RelatedTicket)?.ToList(), Is.EquivalentTo(new[] { ticket2, ticket3 }), "Correct related tickets");
Assert.That(result?.Select(x => x?.Direction)?.ToList(), Is.EquivalentTo(new[] { HierarchicalRelationshipDirection.Descendent, HierarchicalRelationshipDirection.Descendent }), "Correct relationship direction");
Assert.That(result?.Select(x => x?.TicketRelationship)?.ToList(), Is.EquivalentTo(new[] { rel1, rel2 }), "Correct ticket relationships");
}
public void IsRelationshipCircular_returns_true_when_a_ticket_in_the_circle_has_no_identity([HasIdentity] DirectionalRelationship rel,
[HasIdentity] Ticket ticket2,
[HasIdentity] Ticket ticket3,
[HasIdentity] TicketRelationship tr1,
[HasIdentity] TicketRelationship tr2,
[HasIdentity] TicketRelationship tr3,
CircularRelationshipDetector sut)
{
var traversibleRelationships = new[] {
new TraversibleRelationship(tr1.GetIdentity(),
null,
ticket2.GetIdentity(),
rel.GetIdentity()),
new TraversibleRelationship(tr2.GetIdentity(),
ticket2.GetIdentity(),
ticket3.GetIdentity(),
rel.GetIdentity()),
new TraversibleRelationship(tr3.GetIdentity(),
ticket3.GetIdentity(),
null,
rel.GetIdentity()),
};
var result = sut.IsRelationshipCircular(rel.GetIdentity(), traversibleRelationships);
Assert.That(result, Is.True);
}
public void IsRelationshipCircular_returns_false_when_a_complex_non_circular_relationship_hierarchy_exists([HasIdentity] DirectionalRelationship rel1,
[HasIdentity] Ticket ticket1,
[HasIdentity] Ticket ticket2,
[HasIdentity] Ticket ticket3,
[HasIdentity] Ticket ticket4,
[HasIdentity] Ticket ticket5,
[HasIdentity] TicketRelationship tr1,
[HasIdentity] TicketRelationship tr2,
[HasIdentity] TicketRelationship tr3,
[HasIdentity] TicketRelationship tr4,
[HasIdentity] TicketRelationship tr5,
[HasIdentity] TicketRelationship tr6,
[HasIdentity] TicketRelationship tr7,
[Frozen, LoggerFor(typeof(CircularRelationshipDetector))] ILog logger,
CircularRelationshipDetector sut)
{
var traversibleRelationships = new[] {
new TraversibleRelationship(tr1.GetIdentity(),
ticket1.GetIdentity(),
ticket2.GetIdentity(),
rel1.GetIdentity()),
new TraversibleRelationship(tr2.GetIdentity(),
ticket1.GetIdentity(),
ticket3.GetIdentity(),
rel1.GetIdentity()),
new TraversibleRelationship(tr3.GetIdentity(),
ticket1.GetIdentity(),
ticket4.GetIdentity(),
rel1.GetIdentity()),
new TraversibleRelationship(tr4.GetIdentity(),
ticket2.GetIdentity(),
ticket3.GetIdentity(),
rel1.GetIdentity()),
new TraversibleRelationship(tr5.GetIdentity(),
ticket2.GetIdentity(),
ticket4.GetIdentity(),
rel1.GetIdentity()),
new TraversibleRelationship(tr6.GetIdentity(),
ticket3.GetIdentity(),
ticket4.GetIdentity(),
rel1.GetIdentity()),
new TraversibleRelationship(tr7.GetIdentity(),
ticket4.GetIdentity(),
ticket5.GetIdentity(),
rel1.GetIdentity()),
};
Assert.That(() => sut.IsRelationshipCircular(rel1.GetIdentity(), traversibleRelationships), Is.False);
}
public void GetTheoreticalTicketRelationships_marks_up_relationships_for_removal([Frozen, InMemory] IEntityData data,
Ticket ticket,
[WithRelationship] IEnumerable <TicketRelationship> relationships,
TicketRelationship toRemove,
TheoreticalRelationshipProvider sut)
{
data.Add(ticket);
foreach (var t in relationships.Select(x => x.PrimaryTicket))
{
data.Add(t);
}
foreach (var relationship in relationships)
{
data.Add(relationship);
}
data.Add(toRemove);
ticket.SecondaryRelationships.ReplaceContents(relationships);
ticket.SecondaryRelationships.Add(toRemove);
var expected = relationships
.Select(x => new TheoreticalRelationship {
PrimaryTicket = x.PrimaryTicket.GetIdentity(),
SecondaryTicket = ticket.GetIdentity(),
Relationship = x.Relationship,
TicketRelationship = x.GetIdentity(),
})
.Append(new TheoreticalRelationship {
PrimaryTicket = toRemove.PrimaryTicket?.GetIdentity(),
SecondaryTicket = toRemove.SecondaryTicket?.GetIdentity(),
Relationship = toRemove.Relationship,
TicketRelationship = toRemove.GetIdentity(),
Type = TheoreticalRelationshipType.Removed,
})
.ToList();
var result = sut.GetTheoreticalTicketRelationships(ticket.GetIdentity(),
removed: new[] { new DeleteRelationshipRequest {
TicketRelationshipId = toRemove.GetIdentity()
} });
Assert.That(result, Is.EquivalentTo(expected));
}
public void CreateTicket_adds_relationships_with_null_secondary_ticket_as_secondary_relationships([Frozen, CreatesATicket] ICreatesTicket wrappedInstance,
[Frozen] IConvertsAddRelationshipRequestsToTicketRelationships relationshipFactory,
TicketRelationship relationship,
Ticket relatedTicket,
CreateTicketRequest request,
AddRelationshipRequest relationshipRequest,
RelationshipPopulatingTicketFactoryDecorator sut)
{
// Arrange
request.RelationshipsToAdd.Add(relationshipRequest);
Mock.Get(relationshipFactory)
.Setup(x => x.Convert(It.IsAny <IEnumerable <AddRelationshipRequest> >()))
.Returns(new [] { relationship });
relationship.PrimaryTicket = relatedTicket;
relationship.SecondaryTicket = null;
// Act
var result = sut.CreateTicket(request);
// Assert
Assert.That(result?.PrimaryRelationships, Does.Not.Contains(relationship));
Assert.That(result?.SecondaryRelationships, Contains.Item(relationship));
}
