public async Task CreateTicketCommand_WithValidInput_ShouldAddMessageToConversationMessagesAndReturnTicketId()
{
var defaultUserId = await RunAsDefaultUserAsync();
var createdOrganizationId = await SeedSampleOrganization();
var command = new CreateTicketCommand
{
OrganizationId = createdOrganizationId,
Title = "Test Ticket Title",
Message = "First Ticket"
};
var ticketId = await SendAsync(command);
var ticket = await FindAsync <Conversation>(ticketId);
ticket.Should().NotBeNull();
ticket.Title.Should().Be("Test Ticket Title");
ticket.Id.Should().Be(ticketId);
var context = GetContext();
var conversationMessage = await context.ConversationMessages.FirstOrDefaultAsync(x => x.ConversationId == ticketId && x.UserId == defaultUserId);
conversationMessage.Should().NotBeNull();
conversationMessage.Message.Should().Be("First Ticket");
}
public async Task <IActionResult> Post([FromBody] CreateTicketModel model)
{
if (model == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var id = Guid.NewGuid();
var command = new CreateTicketCommand
{
Id = id,
FlightNumber = model.FlightNumber,
Price = model.Price
};
await _commandBus.ExecuteAsync(command);
return(Ok());
}
public void ThrowArgumentOutOfRangeException_WhenJourneyIsNotInDatabase(string journeyParam, string administrativeCostsParam)
{
// Arrange
string journeyID = journeyParam;
string administrativeCosts = administrativeCostsParam;
List <string> parameters = new List <string>()
{
journeyID,
administrativeCosts
};
var journeyMock = new Mock <IJourney>();
List <ITicket> tickets = new List <ITicket>();
List <IJourney> journeys = new List <IJourney>();
journeys.Add(journeyMock.Object);
var databaseMock = new Mock <IDatabase>();
var factoryMock = new Mock <ITravellerFactory>();
var ticketMock = new Mock <ITicket>();
databaseMock.SetupGet(m => m.Tickets).Returns(tickets);
databaseMock.SetupGet(m => m.Journeys).Returns(journeys);
factoryMock.Setup(m => m.CreateTicket(journeyMock.Object, It.IsAny <decimal>())).Returns(ticketMock.Object);
var command = new CreateTicketCommand(factoryMock.Object, databaseMock.Object);
// Act & Assert
Assert.ThrowsException <ArgumentOutOfRangeException>(() => command.Execute(parameters));
}
public ActionResult <Ticket> CreateTicket([FromBody] Ticket ticket)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var empireQueue = _unitOfWork.EmpireQueues.Find(eq => eq.TicketCategoryId == ticket.TicketCategoryId).Single();
var ticketCategory = _unitOfWork.TicketCategories.Get(ticket.TicketCategoryId);
int lastNo = empireQueue.LastIssuedTicketNumber.GetValueOrDefault();
ticket.TicketStatus = TicketStatus.Waiting;
ticket.Number = GetNextNumber(lastNo, ticketCategory.FirstTicketNumber, ticketCategory.LastTicketNumber);
ticket.CreatedDate = DateTime.Now;
_unitOfWork.Tickets.Create(ticket);
empireQueue.LastIssuedTicketNumber = ticket.Number;
_unitOfWork.EmpireQueues.Update(empireQueue);
var createTicketCommand = new CreateTicketCommand(ticket);
_unitOfWork.SourceEvent(createTicketCommand);
PrintTicketAsPdf(ticket);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(Ok(ticket));
}
public void CreateNewTicket(TicketInputModel model)
{
var cmd = new CreateTicketCommand(model.Title, model.Description, model.Status, model.Priority, model.Type,
model.DueDate, model.ResolutionComments, model.RequestorLoginName, model.AssignedToLoginName, model.Category);
_bus.Send(cmd);
}
public void ThrowsArgumentException_When_ArgumentIsNull()
{
this.createTicketCommand = new CreateTicketCommand(this.travelerFactoryMock.Object,
this.dataStoreMock.Object, this.commandConstants);
Assert.That(() => createTicketCommand.Execute(null), Throws.ArgumentException);
}
public void ThrowsArgumentException_When_JourneyDoesNotExistInDataStore()
{
var journeyId = 999;
var args = new List <string> {
journeyId.ToString(), "21"
};
var journyStub1 = new Mock <IJourney>();
var journyStub2 = new Mock <IJourney>();
var journyStub3 = new Mock <IJourney>();
var dataStoredJourneys = new List <IJourney>
{
journyStub1.Object,
journyStub2.Object,
journyStub3.Object
};
this.dataStoreMock
.Setup(x => x.Journeys)
.Returns(dataStoredJourneys);
this.createTicketCommand = new CreateTicketCommand(this.travelerFactoryMock.Object,
this.dataStoreMock.Object, this.commandConstants);
Assert.That(() => this.createTicketCommand.Execute(args), Throws.ArgumentException);
}
public void CallCreteTicketFromTravellerFactory_When_PassedValidArgumentLists()
{
var args = new List <string> {
"0", "21"
};
var journyStub = new Mock <IJourney>();
this.travelerFactoryMock
.Setup(x => x.CreateTicket(It.IsAny <IJourney>(), It.IsAny <decimal>()));
this.dataStoreMock
.Setup(x => x.Journeys)
.Returns(new List <IJourney> {
journyStub.Object
});
this.createTicketCommand =
new CreateTicketCommand(this.travelerFactoryMock.Object,
this.dataStoreMock.Object, this.commandConstants);
createTicketCommand.Execute(args);
this.travelerFactoryMock
.Verify(x => x.CreateTicket(It.IsAny <IJourney>(), It.IsAny <decimal>()), Times.Once);
}
public void ReturnSuccessMessage_WhenDataIsValid()
{
// Arrange
var dataMock = new Mock <IData>();
var factoryMock = new Mock <ITravellerFactory>();
var executeCommand = new CreateTicketCommand(dataMock.Object, factoryMock.Object);
var validParameters = new List <string> {
"0", "30"
};
var journeyMock = new Mock <IJourney>();
var listOfJourneys = new List <IJourney>()
{
journeyMock.Object
};
dataMock.Setup(x => x.Journeys).Returns(listOfJourneys);
var ticketMock = new Mock <ITicket>();
var listOfTickets = new List <ITicket>()
{
ticketMock.Object
};
dataMock.Setup(x => x.Tickets).Returns(listOfTickets);
// Act
var result = executeCommand.Execute(validParameters);
//Assert
StringAssert.Contains(result, "was created.");
}
public void CreateTicketAndAddItToDatabase_WhenParametersAreCorrect()
{
//Arrange
var databaseMock = new Mock <IDatabase>();
var travellerFactoryMock = new Mock <ITravellerFactory>();
var ticketMock = new Mock <ITicket>();
var journeyMock = new Mock <IJourney>();
databaseMock.Setup(m => m.Journeys.Add(journeyMock.Object));
List <ITicket> tickets = new List <ITicket>();
databaseMock.SetupGet(m => m.Tickets).Returns(tickets);
//databaseMock.Object.Tickets.
List <string> commandLine = new List <string>()
{
"0",
"30"
};
travellerFactoryMock.Setup(m => m.CreateTicket(journeyMock.Object, 0)).Returns(ticketMock.Object);
var command = new CreateTicketCommand(databaseMock.Object, travellerFactoryMock.Object);
//Act
command.Execute(commandLine);
//Assert
Assert.AreEqual(1, databaseMock.Object.Tickets.Count);
Assert.AreEqual(ticketMock.Object, databaseMock.Object.Tickets.First());
}
public void CreateTicket_WhenDataIsValid()
{
// Arrange
var dataMock = new Mock <IData>();
var factoryMock = new Mock <ITravellerFactory>();
var executeCommand = new CreateTicketCommand(dataMock.Object, factoryMock.Object);
var validParameters = new List <string> {
"0", "30"
};
var journeyMock = new Mock <IJourney>();
var listOfJourneys = new List <IJourney>()
{
journeyMock.Object
};
dataMock.Setup(x => x.Journeys).Returns(listOfJourneys);
var ticketMock = new Mock <ITicket>();
var listOfTickets = new List <ITicket>()
{
ticketMock.Object
};
dataMock.Setup(x => x.Tickets).Returns(listOfTickets);
factoryMock.Setup(x => x.CreateTicket(journeyMock.Object, 30.00M)).Callback(() => listOfJourneys.Add(journeyMock.Object));
// Act
var result = executeCommand.Execute(validParameters);
//Assert
factoryMock.Verify(x => x.CreateTicket(journeyMock.Object, 30.00M), Times.Once);
}
public void ShouldThrowExceptions_WhenParametersAreIncorrect()
{
//Arrange
string wrongAdministrativeCosts = "1";
string wrongJourney = "1";
List <string> parameters = new List <string>
{
wrongJourney,
wrongAdministrativeCosts
};
var travellerFactoryMock = new Mock <ITravellerFactory>();
var databaseMock = new Mock <ITravellerDatabase>();
var journeyMock = new Mock <IJourney>();
var ticketMock = new Mock <ITicket>();
List <IJourney> journeys = new List <IJourney>();
journeys.Add(journeyMock.Object);
List <ITicket> tickets = new List <ITicket>();
databaseMock.SetupGet(x => x.Journeys).Returns(journeys);
databaseMock.SetupGet(x => x.Tickets).Returns(tickets);
travellerFactoryMock.Setup(x => x.CreateTicket(It.IsAny <IJourney>(), It.IsAny <decimal>())).Returns(ticketMock.Object);
CreateTicketCommand command = new CreateTicketCommand(databaseMock.Object, travellerFactoryMock.Object);
//Act & Assert
string currentResult = command.Execute(parameters);
}
public void ReturnSuccessfulCreatingMesseage_WhenParametersAreCorrcet()
{
string administrativeCosts = "30";
string currentJourney = "0";
//Arrange
List <string> parameters = new List <string>
{
currentJourney,
administrativeCosts
};
var travellerFactoryMock = new Mock <ITravellerFactory>();
var databaseMock = new Mock <ITravellerDatabase>();
var journeyMock = new Mock <IJourney>();
var ticketMock = new Mock <ITicket>();
List <IJourney> journeys = new List <IJourney>();
journeys.Add(journeyMock.Object);
List <ITicket> tickets = new List <ITicket>();
databaseMock.SetupGet(x => x.Journeys).Returns(journeys);
databaseMock.SetupGet(x => x.Tickets).Returns(tickets);
travellerFactoryMock.Setup(x => x.CreateTicket(It.IsAny <IJourney>(), It.IsAny <decimal>())).Returns(ticketMock.Object);
CreateTicketCommand command = new CreateTicketCommand(databaseMock.Object, travellerFactoryMock.Object);
//Act
string currentResult = command.Execute(parameters);
//Assert
Assert.AreEqual(currentResult, SuccessMessage);
}
public void ReturnCreatedTicketSuccessMessage_When_PassedValidArgumentLists()
{
var ticketId = 112;
var args = new List <string> {
"0", "21"
};
var journyStub = new Mock <IJourney>();
var ticketStub = new Mock <ITicket>();
this.travelerFactoryMock
.Setup(x => x.CreateTicket(It.IsAny <IJourney>(), It.IsAny <decimal>()))
.Returns(ticketStub.Object);
this.dataStoreMock
.Setup(x => x.Journeys)
.Returns(new List <IJourney> {
journyStub.Object
});
this.dataStoreMock
.Setup(x => x.AddTicket(ticketStub.Object)).Returns(() => ticketId);
this.createTicketCommand = new CreateTicketCommand(this.travelerFactoryMock.Object,
this.dataStoreMock.Object, this.commandConstants);
var expectedMessage = string.Format(this.commandConstants.TicketCreatedSuccessMessage, ticketId);
var actualMessage = createTicketCommand.Execute(args);
Assert.That(actualMessage, Is.EqualTo(expectedMessage));
}
public void DeveRetornarSucessoSeCommandValido(
int clientId,
string nome,
string sobrenome,
string email,
string token,
string empresa,
string telefone,
string title,
string description,
ETicketStatusType status,
EPriorityType prioridade
)
{
CreateTicketCommand command = new CreateTicketCommand
{
ClientId = clientId,
ClientFirstName = nome,
ClientLastName = sobrenome,
ClientEmail = email,
ClientToken = token,
ClientCompany = empresa,
ClientCallNumber = telefone,
Title = title,
Description = description,
Status = status,
Priority = prioridade
};
command.Validate();
Assert.True(command.Valid);
}
public void CreateTicketCommand_WithoutAnyInput_ShouldThrowValidationException()
{
var command = new CreateTicketCommand();
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <ValidationException>();
}
void AndGivenCommandPrepared()
{
_command = new CreateTicketCommand
{
Email = "*****@*****.**",
Subject = "Example subject",
Text = "Example text"
};
}
public async Task <IActionResult> Create(CreateTicketCommand createTicketCommand)
{
var result = await Mediator.Send(createTicketCommand);
if (result.Success == false)
{
return(result.ApiResult);
}
return(Created(Url.Link("GetTicketInfo", new { id = result.Data.Id }), result.Data));
}
public async Task <IActionResult> Create([FromBody] CreateTicketCommand command)
{
var ticket = await Mediator.Send(command);
if (ticket == null)
{
return(BadRequest());
}
return(Ok(ticket));
}
public void ReturnInstance_WhenArgumentsAreValid()
{
// Arrange
var databaseMock = new Mock <IDatabase>();
var factoryMock = new Mock <ITravellerFactory>();
// Act
var createTicketCommand = new CreateTicketCommand(factoryMock.Object, databaseMock.Object);
// Assert
Assert.IsNotNull(createTicketCommand);
}
public void ThrowsArgumentException_When_CannotParseArgumentList()
{
var args = new List <string> {
"Sofia", "vTurnovo"
};
this.createTicketCommand = new CreateTicketCommand(this.travelerFactoryMock.Object,
this.dataStoreMock.Object, this.commandConstants);
Assert.That(() => this.createTicketCommand.Execute(args), Throws.ArgumentException);
}
public void ReturnAnInstanceOfTicketClass_WhenParametersAreCorrect()
{
// Arrange
var travellerFactoryMock = new Mock <ITravellerFactory>();
var databaseMock = new Mock <IDatabase>();
// Act
var ticketCreation = new CreateTicketCommand(travellerFactoryMock.Object, databaseMock.Object);
// Assert
Assert.IsNotNull(ticketCreation);
}
public void ConstructorShould_CorrectlyAssignFactory()
{
// Arrange
var databaseStub = new Mock <IDatabase>();
var factoryStub = new Mock <ITravellerFactory>();
// Act
var createTicketCommand = new CreateTicketCommand(databaseStub.Object, factoryStub.Object);
// Assert
Assert.AreSame(factoryStub.Object, createTicketCommand.Factory);
}
public void ShouldReturnInstance_WhenParametersAreValid()
{
// Arrange
var travellerFactoryMock = new Mock <ITravellerFactory>();
var databaseMock = Helpers.InitializeDatabaseMock();
// Act
var instance = new CreateTicketCommand(travellerFactoryMock.Object, databaseMock.Object);
// Assert
Assert.IsNotNull(instance);
}
public void ReturnInstance_WhenParametersAreCorrect()
{
// Arrange
var databaseMock = new Mock <IDatabase>();
var factoryMock = new Mock <ITravellerFactory>();
// Act
var createTicketCommmand = new CreateTicketCommand(databaseMock.Object, factoryMock.Object);
// Assert
Assert.IsNotNull(createTicketCommmand);
}
public async Task CreateTicketCommand_WithoutMessage_ShouldThrowValidationException()
{
var createdOrganizationId = await SeedSampleOrganization();
var command = new CreateTicketCommand
{
Title = "Test",
OrganizationId = createdOrganizationId
};
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <ValidationException>();
}
public async Task CreateTicketCommand_WithoutOrganizationId_ShouldThrowValidationException()
{
var defaultUserId = await RunAsDefaultUserAsync();
var command = new CreateTicketCommand
{
Title = "Test",
Message = "Test"
};
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <ValidationException>();
}
public void ThrowsArgumentException_WhenDataIsInvalid()
{
// Arrange
var dataMock = new Mock <IData>();
var factoryMock = new Mock <ITravellerFactory>();
var executeCommand = new CreateTicketCommand(dataMock.Object, factoryMock.Object);
// Act & Assert
Assert.ThrowsException <ArgumentException>(() => executeCommand.Execute(new List <string> {
"Invalid", "Parameters"
}));
}
public void ThrowException_WhenDatabaseArgumentIsNull()
{
// Arrange
var factory = new Mock <ITravellerFactory>();
var database = new Mock <IDatabase>();
// Act &
var factoryNull = new CreateTicketCommand(factory.Object,
null);
//Assert
Assert.Fail();
}
public void CreateTicketCommand_WithInvalidOrganizationId_ShouldThrowNotFoundException()
{
var invalidOrganizationId = new Guid("ef1dc766-98f5-424f-ad4c-0fb42a690140");
var command = new CreateTicketCommand
{
OrganizationId = invalidOrganizationId,
Title = "Test",
Message = "Test"
};
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <NotFoundException>();
}
