public void CreateHandler_CreateExpense_VerifyAddExpense()
        {
            var token = new CancellationTokenSource().Token;

            _mockCreateHandler
            .Setup(c => c.Handle(_createCommand, token))
            .Returns(It.IsAny <Task <Unit> >());

            _mockMapper
            .Setup(m => m.Map <ExpenseDTO, Expense>(_createCommand.Expense))
            .Returns(_expense);


            using (var context = new ExpenseTrackerDbContext(_options))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                _createHandler = new Create.Handler(context, _mockMapper.Object);

                _createHandler.Handle(_createCommand, token).Wait();
                var actual = context.Expenses.CountAsync().Result;

                Assert.Equal(1, actual);
            }
        }
        /// <summary>
        /// creates an article comment based on the given Create command.
        /// Creates a default user if parameter userName is empty.
        /// </summary>
        /// <param name="fixture"></param>
        /// <param name="command"></param>
        /// <param name="userName"></param>
        /// <returns></returns>
        public static async Task <Domain.Comment> CreateComment(SliceFixture fixture, Create.Command command, string userName)
        {
            if (string.IsNullOrWhiteSpace(userName))
            {
                var user = await UserHelpers.CreateDefaultUser(fixture);

                userName = user.Username;
            }

            var dbContext       = fixture.GetDbContext();
            var currentAccessor = new StubCurrentUserAccessor(userName);

            var commentCreateHandler = new Create.Handler(dbContext, currentAccessor);
            var created = await commentCreateHandler.Handle(command, new System.Threading.CancellationToken());

            var dbArticleWithComments = await fixture.ExecuteDbContextAsync(
                db => db.Articles
                .Include(a => a.Comments).Include(a => a.Author)
                .Where(a => a.Slug == command.Slug)
                .SingleOrDefaultAsync()
                );

            var dbComment = dbArticleWithComments.Comments
                            .Where(c => c.ArticleId == dbArticleWithComments.ArticleId && c.Author == dbArticleWithComments.Author)
                            .FirstOrDefault();

            return(dbComment);
        }
Esempio n. 3
0
        public async Task Create_Component_LoggedWithValidInput_Should_CreateComponent()
        {
            var fixture                  = new Fixture();
            var mockedContext            = new EletronicPartsCatalogContextMock().GetMockedContextWithData();
            var mockedCurrentUserAcessor = new Mock <ICurrentUserAccessor>();

            mockedCurrentUserAcessor.Setup(mcua => mcua.GetCurrentUsername()).Returns("test");

            var sut = new Create.Handler(mockedContext, mockedCurrentUserAcessor.Object);

            var wheretofinditlist = fixture.Create <string[]>();

            var message = new Create.Command
            {
                Component = new Create.ComponentData()
                {
                    Name              = "Component",
                    Description       = "Description",
                    WhereToFindItList = wheretofinditlist
                }
            };

            var result = await sut.Handle(message, CancellationToken.None);

            Assert.Equal(result.Component.Description, message.Component.Description);
        }
Esempio n. 4
0
        public async Task Create_Project_LoggedWithValidInput_Should_CreateProject()
        {
            var fixture                  = new Fixture();
            var mockedContext            = new EletronicPartsCatalogContextMock().GetMockedContextWithData();
            var mockedCurrentUserAcessor = new Mock <ICurrentUserAccessor>();

            mockedCurrentUserAcessor.Setup(mcua => mcua.GetCurrentUsername()).Returns("test");

            var sut = new Create.Handler(mockedContext, mockedCurrentUserAcessor.Object);

            var compentlist = fixture.Create <string[]>();
            var taglist     = fixture.Create <string[]>();

            var message = new Create.Command
            {
                Project = new Create.ProjectData
                {
                    ComponentList = compentlist,
                    Title         = "Title",
                    Description   = "Description",
                    Body          = "Body",
                    TagList       = taglist
                }
            };

            var result = await sut.Handle(message, CancellationToken.None);

            Assert.Equal(result.Project.Title, message.Project.Title);
        }
Esempio n. 5
0
        public void Should_Create_License()
        {
            var context = GetDbContext();

            var modalityId = Guid.NewGuid();

            context.Modalities.Add(new Modality {
                Id = modalityId, Name = "Test Modality"
            });

            context.SaveChanges();

            var licenseCreateCommand = new Create.Command
            {
                Id          = Guid.NewGuid(),
                Name        = "Test License",
                DisplayName = "TL",
                ModalityId  = modalityId
            };

            var sut = new Create.Handler(context);

            var result = sut.Handle(licenseCreateCommand, CancellationToken.None).Result;

            var license = context.Licenses.FirstOrDefault(x => x.ModalityId == modalityId);

            Assert.NotNull(license);
            Assert.Equal("Test License", license.Name);
        }
Esempio n. 6
0
        public void Should_Not_Create_Shift_With_Invalid_Ids()
        {
            var context = GetDbContext();

            var CreateShiftCommandWithInvalidIds = new Create.Command
            {
                Id             = Guid.NewGuid(),
                Start          = DateTime.Now,
                End            = DateTime.Now.AddHours(8),
                TechnologistId = Guid.NewGuid(),
                ModalityId     = Guid.NewGuid(),
                LicenseId      = Guid.NewGuid(),
                LocationId     = Guid.NewGuid(),
                RoomId         = Guid.NewGuid()
            };

            var sut = new Create.Handler(context);
            var ex  = Assert.ThrowsAsync <RestException>(() => sut.Handle(CreateShiftCommandWithInvalidIds, CancellationToken.None));

            var errors = (IDictionary <string, object>)ex.Result.Errors;

            var locationError     = errors["location"];
            var licenseError      = errors["license"];
            var roomError         = errors["room"];
            var modalityError     = errors["modality"];
            var technologistError = errors["technologist"];

            Assert.Equal("Invalid Location", locationError);
            Assert.Equal("Invalid License", licenseError);
            Assert.Equal("Invalid Room", roomError);
            Assert.Equal("Invalid Modality", modalityError);
            Assert.Equal("Invalid Technologist", technologistError);
        }
Esempio n. 7
0
        public async Task Create_Project_NotLogged_WithValidInput_ShouldReturn_InvalidOperationException()
        {
            var fixture                  = new Fixture();
            var mockedContext            = new EletronicPartsCatalogContextMock().GetMockedContextWithData();
            var mockedCurrentUserAcessor = new Mock <ICurrentUserAccessor>();

            var sut = new Create.Handler(mockedContext, mockedCurrentUserAcessor.Object);

            var compentlist = fixture.Create <string[]>();
            var taglist     = fixture.Create <string[]>();

            var message = new Create.Command
            {
                Project = new Create.ProjectData
                {
                    ComponentList = compentlist,
                    Title         = "Title",
                    Description   = "Description",
                    Body          = "Body",
                    TagList       = taglist
                }
            };

            await Assert.ThrowsAsync <InvalidOperationException>(() => sut.Handle(message, CancellationToken.None));
        }
Esempio n. 8
0
        public void Should_Create_Technologist()
        {
            var context = GetDbContext();

            var modalityId = Guid.NewGuid();

            context.Modalities.Add(new Domain.Modality {
                Id = modalityId, Name = "Test Modality", DisplayName = "TM"
            });
            context.SaveChanges();

            var sut = new Create.Handler(context);



            var result = sut.Handle(new Create.Command
            {
                Id            = Guid.NewGuid(),
                Name          = "Test Technologist",
                ModalityId    = modalityId,
                Initial       = "TT",
                LicenseIdList = new List <Guid> {
                }
            }
                                    , CancellationToken.None).Result;


            var technologist = context.Technologists.FirstOrDefault(x => x.ModalityId == modalityId);

            Assert.NotNull(technologist);
            Assert.Equal("Test Technologist", technologist.Name);
        }
Esempio n. 9
0
        public void Should_Fail_With_Invalid_Location()
        {
            var context = GetDbContext();

            context.Locations.Add(new Location {
                Id = Guid.NewGuid(), Name = "Location In Db"
            });
            context.SaveChanges();


            var CreateCommandInvalidLocationId = new Create.Command
            {
                Id         = Guid.NewGuid(),
                Name       = "Test Room",
                LocationId = Guid.NewGuid()
            };

            //act
            var sut = new Create.Handler(context);
            var ex  = Assert.ThrowsAsync <RestException>(() => sut.Handle(CreateCommandInvalidLocationId, CancellationToken.None));

            var thrownError   = ex.Result.Errors.ToString();
            var expectedError = (new { location = "Could not find location" }).ToString();

            Assert.Equal(expectedError, thrownError);
        }
Esempio n. 10
0
        public void Should_Create_Room()
        {
            //arrange
            var context = GetDbContext();

            var locationId = Guid.NewGuid();

            var location = new Location
            {
                Id   = locationId,
                Name = "LocationForRoomTest"
            };

            context.Locations.Add(location);
            context.SaveChanges();

            var roomId  = Guid.NewGuid();
            var command = new Create.Command
            {
                Id         = roomId,
                Name       = "Test Room",
                LocationId = locationId
            };

            //act
            var sut    = new Create.Handler(context);
            var result = sut.Handle(command, CancellationToken.None).Result;

            var room = context.Rooms.FirstOrDefaultAsync(x => x.LocationId == locationId).Result;

            Assert.NotNull(room);
            Assert.Equal("Test Room", room.Name);
        }
Esempio n. 11
0
        public static async Task <ArticleCategoriesEnvelope> ListCategories(SliceFixture fixture, Conduit.Features.ArticleCategories.List.Query command)
        {
            // first create the default user
            var user = await UserHelpers.CreateDefaultUser(fixture);

            var dbContext       = fixture.GetDbContext();
            var currentAccessor = new StubCurrentUserAccessor(user.Username);

            var createCategoryCommand = new Create.Command()
            {
                articleCategory = new ArticleCategory()
                {
                    CategoryId = 1,
                    ArticleId  = 1
                }
            };

            var categoryCreateHandler = new Create.Handler(dbContext, currentAccessor);
            var createdCategory       = await categoryCreateHandler.Handle(createCategoryCommand, new System.Threading.CancellationToken());


            var categoryQueryHandler = new List.QueryHandler(dbContext, currentAccessor);
            var queriedCategories    = await categoryQueryHandler.Handle(command, new System.Threading.CancellationToken());


            return(queriedCategories);
        }
Esempio n. 12
0
        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;

            _jobEditCommand = new Edit.Command
            {
                JobName     = "TestJob1",
                Company     = "Netapp",
                Replication = "Zerto",
                Servers     = "7",
                LastRun     = DateTime.Now,
                RTA         = "10",
                Results     = "OK",
                Key         = "AAAA-BBBB-CCCC-DDDD",
                RTONeeded   = "20",
            };
        }
        public static async Task <CategoriesEnvelope> ListCategories(SliceFixture fixture, List.Query command)
        {
            // first create the default user
            var user = await UserHelpers.CreateDefaultUser(fixture);

            var dbContext       = fixture.GetDbContext();
            var currentAccessor = new StubCurrentUserAccessor(user.Username);

            var createCategoryCommand = new Create.Command()
            {
                Category = new Create.CategoryData()
                {
                    ParentCategory = 0,
                    Name           = "TestCategory",
                    Description    = "This is a test Category"
                }
            };

            var categoryCreateHandler = new Create.Handler(dbContext, currentAccessor);
            var createdCategory       = await categoryCreateHandler.Handle(createCategoryCommand, new System.Threading.CancellationToken());


            var categoryQueryHandler = new List.QueryHandler(dbContext, currentAccessor);
            var queriedCategories    = await categoryQueryHandler.Handle(command, new System.Threading.CancellationToken());


            return(queriedCategories);
        }
Esempio n. 14
0
        public void Should_Fail_License_Create_W_Invalid_Modality()
        {
            var context = GetDbContext();

            context.Modalities.Add(new Modality {
                Id = Guid.NewGuid(), Name = "Test Modality"
            });

            context.SaveChanges();

            var licenseCreateCommand = new Create.Command
            {
                Id          = Guid.NewGuid(),
                Name        = "Test License",
                DisplayName = "TL",
                ModalityId  = Guid.NewGuid()
            };

            var sut = new Create.Handler(context);

            var ex = Assert.ThrowsAsync <RestException>(() => sut.Handle(licenseCreateCommand, CancellationToken.None));

            var thrownError   = ex.Result.Errors.ToString();
            var expectedError = (new { modality = "Modality not found" }).ToString();

            Assert.Equal(expectedError, thrownError);
        }
Esempio n. 15
0
        public void Should_Create_Game()
        {
            var userAccessor      = new Mock <IUserAccessor>();
            var userManager       = new Mock <UserManager <Player> >();
            var gameCodeGenerator = new Mock <IGameCodeGenerator>();

            userAccessor.Setup(u => u.GetCurrentUserName()).Returns("mainplayer");

            var context = GetDbContext();

            context.Users.AddAsync(new Player
            {
                Id       = "a",
                Email    = "*****@*****.**",
                UserName = "******"
            });
            context.SaveChangesAsync();

            var gameCommand = new Create.Command
            {
                Title    = "Game1",
                MinPoint = "3",
                MaxPoint = "10"
            };

            var sut    = new Create.Handler(context, userAccessor.Object, _mapper, userManager.Object, gameCodeGenerator.Object);
            var result = sut.Handle(gameCommand, CancellationToken.None).Result;

            Assert.Equal("Game1", result.Title);
        }
Esempio n. 16
0
        public CreateTest()
        {
            trailsServiceMock = new Mock <ITrailsService>();
            userManager       = MockHelpers.MockUserManager <User>();
            userAccessor      = MockHelpers.TestUserAccessor();

            trailsServiceMock.Setup(x => x.AddAsync(It.IsAny <Trail>())).ReturnsAsync(true);
            trailsServiceMock.Setup(t => t.FindByNameAsync(It.IsAny <string>())).ReturnsAsync(TrailsMockData.CreateTrail_US_Mock);
            userManager.Setup(s => s.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(MockHelpers.MockProUser);
            createHandler = new Create.Handler(userManager.Object, userAccessor, trailsServiceMock.Object);
        }
Esempio n. 17
0
        public void CreateJob_WithValidInput_ShouldCreateJob()
        {
            //Arrange
            var handler = new Create.Handler(testContext);
            //Act
            var result = handler.Handle(_jobCommand, CancellationToken.None).Result;

            //Assert
            Assert.NotNull(result);
            Assert.That(result.Equals(Unit.Value));
        }
        public CreateUserHandlerTests()
        {
            var users = new[]
            {
                new User("sanjay", "*****@*****.**", "sanjay_11", "Sanjay", "Idpuganti")
            };

            _context.Users.AddRange(users);
            _context.SaveChanges();
            var repository = new UserRepository(_context);

            _handler = new Create.Handler(repository);
        }
        public static async Task <Appointment> CreateAppointment(TestFixture fixture, Create.Command command)
        {
            var dbContext = fixture.GetDbContext();

            var appointmentCreateHandler = new Create.Handler(dbContext);
            var created = await appointmentCreateHandler.Handle(command, new CancellationToken());

            var dbAppointment = await fixture.ExecuteDbContextAsync(db => db.Appointments
                                                                    .Where(a => a.AppointmentId == created.Appointment.AppointmentId)
                                                                    .SingleOrDefaultAsync());

            return(dbAppointment);
        }
Esempio n. 20
0
        public void CreateJob_WhenJobIdExists_ShouldThrowException()
        {
            //Arrange
            var handler = new Create.Handler(testContext);
            //Act
            var result = handler.Handle(_jobCommand, CancellationToken.None).Result;
            //Assert
            var ex = Assert.CatchAsync <Exception>(() => handler.Handle(_jobCommand, CancellationToken.None));

            if (ex.Equals(typeof(Exception)))
            {
                Assert.That(ex.Message, Is.EqualTo("problem saving changes"));
            }
        }
Esempio n. 21
0
        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);
            }
        }
Esempio n. 22
0
        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);
        }
Esempio n. 23
0
        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);
        }
Esempio n. 24
0
        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));
        }
Esempio n. 25
0
        public void SetUp()
        {
            //first we'll create a new jobaction - as our db is currently empty
            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;
        }
Esempio n. 26
0
        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);
        }
Esempio n. 27
0
        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));
        }
Esempio n. 28
0
        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);
        }
Esempio n. 29
0
        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));
            }
        }