public void GivenAnOrderViewOrderDetails()
{
using var factory = new DbContextFactory <ShopContext>();
var options = factory.CreateOptions();
using var context = factory.CreateContext(options);
var createProductHandler = new Features.Products.Create.Handler(context);
var foo = createProductHandler.Handle(new Features.Products.Create.Command {
Code = "Foo", Description = "Foo description"
}, default).Result;
var bar = createProductHandler.Handle(new Features.Products.Create.Command {
Code = "Bar", Description = "Bar description"
}, default).Result;
// Create an order
var createCommand = new Create.Command
{
DateCreated = new DateTime(2019, 1, 1),
Lines = new List <Create.Command.OrderLine>
{
new Create.Command.OrderLine {
ProductCode = foo, Quantity = 1
},
new Create.Command.OrderLine {
ProductCode = bar, Quantity = 3
},
}
};
var createHandler = new Create.Handler(context);
var orderNumber = createHandler.Handle(createCommand, default).Result;
// View order details
var query = new Details.Query {
Number = orderNumber
};
var detailsHandler = new Details.Handler(context);
var orderDetails = detailsHandler.Handle(query, default).Result;
Assert.AreEqual(createCommand.DateCreated, orderDetails.CreatedDate);
Assert.AreEqual(createCommand.Lines.Count(), orderDetails.Lines.Count());
foreach (var(line, index) in orderDetails.Lines.Select((l, i) => (l, i)))
{
var orderLine = createCommand.Lines.Single(x => x.ProductCode == line.ProductCode);
var orderLineNumber = index + 1;
Assert.AreEqual(orderLineNumber, line.Number);
Assert.AreEqual(orderLine.Quantity, line.Quantity);
}
}
public async Task Handle_CallsAddAsyncWithValidRequest_SavesAndReturnsNewTrail()
{
//Arrange
var validRequest = TrailsMockData.Trail_CreateQuery_US_Mock;
//Act
Trail newTrail = await createHandler.Handle(validRequest, MockHelpers.CancellationToken);
//Assert
trailsServiceMock.Verify(x => x.AddAsync(It.IsAny <Trail>()), Times.Once);
trailsServiceMock.Verify(x => x.FindByNameAsync(It.IsAny <string>()), Times.Once);
userManager.Verify(x => x.FindByIdAsync(It.IsAny <string>()), Times.Once);
Assert.IsType <Trail>(newTrail);
Assert.Equal("Created Trail", newTrail.Name);
}
public static async Task <Domain.Article> CreateArticle(SliceFixture fixture, Create.Command command)
{
var user = await UserHelpers.CreateDefaultUser(fixture);
var dbContext = fixture.GetDbContext();
var currentUserAccessor = new StubCurrentUserAccessor(user.Username);
var handler = new Create.Handler(dbContext, currentUserAccessor);
var created = await handler.Handle(command, new CancellationToken());
var article = await fixture.ExecuteDbContextAsync(context =>
context.Articles.Where(a => a.ArticleId == created.Article.ArticleId).SingleOrDefaultAsync());
return(article);
}
public static async Task <Domain.ArticleCategory> CreateArticleCategory(SliceFixture fixture, Create.Command command)
{
// first create the default user
var user = await UserHelpers.CreateDefaultUser(fixture);
var dbContext = fixture.GetDbContext();
var currentAccessor = new StubCurrentUserAccessor(user.Username);
var categoryCreateHandler = new Create.Handler(dbContext, currentAccessor);
var created = await categoryCreateHandler.Handle(command, new System.Threading.CancellationToken());
var dbCategory = await fixture.ExecuteDbContextAsync(db => db.ArticleCategories.Where(a => a.ArticleCategoryId == created.ArticleCategoryId)
.SingleOrDefaultAsync());
return(dbCategory);
}
public void SetUp()
{
var jobCommand = new Create.Command
{
JobName = "TestJob1",
Company = "Netapp",
Replication = "Zerto",
Servers = "7",
LastRun = DateTime.Now,
RTA = "10",
Results = "OK",
Key = "AAAA-BBBB-CCCC-DDDD",
RTONeeded = "20",
};
var handler = new Create.Handler(testContext);
var result = handler.Handle(jobCommand, CancellationToken.None).Result;
}
public async Task Create_Comment_NotLogged_WithValidInput_ShouldReturn_InvalidOperationException()
{
var mockedContext = new EletronicPartsCatalogContextMock().GetMockedContextWithData();
var mockedCurrentUserAcessor = new Mock <ICurrentUserAccessor>();
var sut = new Create.Handler(mockedContext, mockedCurrentUserAcessor.Object);
var message = new Create.Command
{
Comment = new Create.CommentData()
{
Body = "Body"
}
};
await Assert.ThrowsAsync <RestException>(() => sut.Handle(message, CancellationToken.None));
}
public void GivenAnOrderViewOrderOverview()
{
using var factory = new DbContextFactory <ShopContext>();
var options = factory.CreateOptions();
using var context = factory.CreateContext(options);
var createProductHandler = new Features.Products.Create.Handler(context);
var foo = createProductHandler.Handle(new Features.Products.Create.Command {
Code = "Foo", Description = "Foo description"
}, default).Result;
var bar = createProductHandler.Handle(new Features.Products.Create.Command {
Code = "Bar", Description = "Bar description"
}, default).Result;
// Create an order
var createCommand = new Create.Command
{
DateCreated = new DateTime(2019, 1, 1),
Lines = new List <Create.Command.OrderLine>
{
new Create.Command.OrderLine {
ProductCode = foo, Quantity = 1
},
new Create.Command.OrderLine {
ProductCode = bar, Quantity = 3
},
}
};
var createHandler = new Create.Handler(context);
var orderNumber = createHandler.Handle(createCommand, default).Result;
// View order overview
var query = new Overview.Query();
var overviewHandler = new Overview.Handler(context);
var overviewPage = overviewHandler.Handle(query, default).Result;
Assert.AreEqual(1, overviewPage.OrdersTotal);
var order = overviewPage.Orders.Single();
Assert.AreEqual(orderNumber, order.Number);
}
public void Should_Create_Modality()
{
var context = GetDbContext();
var modalityCreateCommand = new Create.Command
{
Id = Guid.NewGuid(),
Name = "Test Modality",
DisplayName = "TM"
};
var sut = new Create.Handler(context);
var result = sut.Handle(modalityCreateCommand, CancellationToken.None).Result;
var newlyCreatedModality = context.Modalities.FirstOrDefaultAsync(x => x.Id == modalityCreateCommand.Id).Result;
Assert.NotNull(newlyCreatedModality);
Assert.Equal("Test Modality", newlyCreatedModality.Name);
Assert.Equal("TM", newlyCreatedModality.DisplayName);
}
public async Task Create_User_WithInvalidInput_ShouldReturn_InvalidOperationException()
{
var mockedContext = new EletronicPartsCatalogContextMock().GetMockedContextWithData();
var mockedHasher = new Mock <IPasswordHasher>();
var mockedJwtTokenGenerator = new Mock <IJwtTokenGenerator>();
var mockedMapper = new Mock <IMapper>();
var sut = new Create.Handler(mockedContext, mockedHasher.Object, mockedJwtTokenGenerator.Object, mockedMapper.Object);
var message = new Create.Command
{
User = new Create.UserData()
{
Username = "******",
Email = "*****@*****.**",
Password = "******",
PasswordConfirmation = "another pass"
}
};
await Assert.ThrowsAsync <NullReferenceException>(() => sut.Handle(message, CancellationToken.None));
}
public async Task CreateBook()
{
// when Debugging is required, System.Diagnostics.Debugger.Launch();
var options = new DbContextOptionsBuilder <LibraryMaterialContext>()
.UseInMemoryDatabase(databaseName: "BookStore")
.Options;
var context = new LibraryMaterialContext(options);
var request = new Create.Execute();
request.Title = "Net Core Micro-services";
request.BookAuthorGuid = Guid.Empty;
request.PublishDate = DateTime.Now;
var handler = new Create.Handler(context);
var result = await handler.Handle(request, new CancellationToken());
Assert.True(result != null);
}
public void CreateHandler_CreateExpenseArgsNull_ThrowsArgumentNullException()
{
var command = new Create.Command {
Expense = null
};
var token = new CancellationTokenSource().Token;
using (var context = new ExpenseTrackerDbContext(_options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
_createHandler = new Create.Handler(context, _mockMapper.Object);
_mockCreateHandler
.Setup(c => c.Handle(command, token))
.Throws <ArgumentNullException>();
Assert.ThrowsAsync <ArgumentNullException>(() =>
_createHandler.Handle(command, token));
}
}
public void setUp()
{
//first we'll create a couple of new jobactions - as our db is currently empty
var jobCommand1 = new Create.Command
{
JobName = "TestJob1",
Company = "Netapp",
Replication = "Zerto",
Servers = "7",
LastRun = DateTime.Now,
RTA = "10",
Results = "OK",
Key = "AAAA-BBBB-CCCC-DDDD",
RTONeeded = "20"
};
var handler1 = new Create.Handler(testContext);
var result = handler1.Handle(jobCommand1, CancellationToken.None).Result;
var jobCommand2 = new Create.Command
{
JobName = "TestJob2",
Company = "EMC",
Replication = "Veeam",
Servers = "30",
LastRun = DateTime.Now,
RTA = "20",
Results = "OK",
Key = "AAAA-BBBB-CCCC-DDDD",
RTONeeded = "30"
};
var handler2 = new Create.Handler(testContext);
result = handler2.Handle(jobCommand2, CancellationToken.None).Result;
}
public void Should_Create_Shift()
{
var context = GetDbContext();
var locationID = Guid.NewGuid();
context.Locations.Add(new Domain.Location {
Id = locationID, Name = "Test Location"
});
context.SaveChanges();
var roomId = Guid.NewGuid();
context.Rooms.Add(new Domain.Room {
Id = roomId, Name = "TL1", LocationId = locationID
});
var modalityID = Guid.NewGuid();
context.Modalities.Add(new Domain.Modality {
Id = modalityID, Name = "Test Modality", DisplayName = "TM"
});
context.SaveChanges();
var licenseId = Guid.NewGuid();
context.Licenses.Add(new Domain.License {
Id = licenseId, Name = "Test License", DisplayName = "TL", ModalityId = modalityID
});
context.SaveChanges();
var technologistId = Guid.NewGuid();
context.Technologists.Add(new Domain.Technologist {
Id = technologistId, Name = "Test Technologist", Initial = "TT", ModalityId = modalityID
});
var shiftId = Guid.NewGuid();
var sut = new Create.Handler(context);
var result = sut.Handle(new Create.Command
{
Id = shiftId,
Start = DateTime.Now,
End = DateTime.Now.AddHours(8),
TechnologistId = technologistId,
ModalityId = modalityID,
LicenseId = licenseId,
LocationId = locationID,
RoomId = roomId
}, CancellationToken.None).Result;
//adding AsNoTracking() to prevent entities being tracked and autoloading
//without no tracking include is not required
var createdShift = context.Set <Shift>().AsNoTracking()
.Include(s => s.License)
.Include(s => s.Modality)
.Include(s => s.Location)
.Include(s => s.Room)
.Include(s => s.Technologist)
.FirstOrDefault(x => x.Id == shiftId);
Assert.Equal("Test Technologist", createdShift.Technologist.Name);
Assert.Equal("Test License", createdShift.License.Name);
}