Example #1
0
        public void CreateAssignedWorkStation_ValidCommand_Verify_WorkStationId_Get_From_ApplicationSettings_Using_Setup_Property()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var mockCustomerRepository  = new Mock <ICustomerRepository>();
            var mockApplicationSettings = new Mock <IApplicationSettings>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny <Customer>()));
            //mockApplicationSettings.Setup(x => x.WorkStationId)
            //    .Returns(10);

            mockApplicationSettings.SetupProperty(x => x.WorkStationId, 123);

            //Can we set if from the object itself??
            //mockApplicationSettings.Object.WorkStationId = 345;

            //mockApplicationSettings.SetupAllProperties();

            CustomerService_8 customerService = new CustomerService_8(
                mockCustomerRepository.Object,
                mockApplicationSettings.Object
                );

            //Act
            customerService.CreateAssignedWorkStation(createCommmand);

            //Assert
            mockApplicationSettings.VerifyGet(x => x.WorkStationId);
        }
Example #2
0
        public void CreateComplexAssignedWorkStation_ValidCommand_Verify_WorkStationId_Get_From_ApplicationSettings()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var mockCustomerRepository  = new Mock <ICustomerRepository>();
            var mockApplicationSettings = new Mock <IApplicationSettings>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny <Customer>()));
            mockApplicationSettings.Setup(x => x.SystemConfiguration.AuditingInformation.WorkStationId)
            .Returns(10);

            CustomerService_8 customerService = new CustomerService_8(
                mockCustomerRepository.Object,
                mockApplicationSettings.Object
                );

            //Act
            customerService.CreateComplexAssignedWorkStation(createCommmand);

            //Assert
            mockApplicationSettings.VerifyGet(x => x.SystemConfiguration.AuditingInformation.WorkStationId);
            mockCustomerRepository.Verify(x => x.Save(It.IsAny <Customer>()));
        }
Example #3
0
        public void Create_ValidCommand_Client_Should_Be_Persisted()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            MailingAddress mailingAddress = new MailingAddress()
            {
                Street = "Test Street", StreetNumber = 10
            };

            var mockRepository            = new Mock <ICustomerRepository>();
            var mockMailingAddressFactory = new Mock <IMailingAddressFactory>();

            mockRepository.Setup(x => x.Save(It.IsAny <Customer>()));

            mockMailingAddressFactory.Setup(x => x.TryParse(It.IsAny <string>(), out mailingAddress))
            .Returns(true);

            CustomerService_4 customerService = new CustomerService_4(mockMailingAddressFactory.Object, mockRepository.Object);

            //Act
            customerService.Create(createCommmand);

            //Assert
            mockRepository.Verify(x => x.Save(It.IsAny <Customer>()));
        }
        public void Create_ValidCommand_Save_Special_If_Customer_Platinum()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockCustomerRepository = new Mock<ICustomerRepository>();
            var mockSatusFactory = new Mock<IStatusFactory>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny<Customer>()));
            mockSatusFactory.Setup(x => x.From(It.IsAny<CustomerCreateCommand>()))
                .Returns(CustomerStatusEnum.Platinum);

            CustomerService_7 customerService = new CustomerService_7(
                mockCustomerRepository.Object,
                mockSatusFactory.Object
                );

            //Act
            customerService.Create(createCommmand);

            //Assert
            mockCustomerRepository.Verify(x => x.SaveSpecial(It.IsAny<Customer>()));

            //Practice: Test the other method..
            //QUESTION: How to verify that the other method is not called.
        }
        public void Verify_That_MailingAddress_Is_Get_From_customerAddressBuilder()
        {
            // Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockedCustomerRepository = new Mock<ICustomerRepository>();
            var mockedMailingFactory = new Mock<IMailingAddressFactory>() { DefaultValue = DefaultValue.Mock };

            var customerService = new CustomerService_91(mockedCustomerRepository.Object, mockedMailingFactory.Object);

            ICustomerAddressBuilder customerAddressBuilder =
                mockedMailingFactory.Object.GetAddressBuilder(true);

            var mockedCustomerAddressBuilder = Mock.Get<ICustomerAddressBuilder>(customerAddressBuilder);

            // Act
            customerService.Create(createCommmand);

            // Assert
            mockedCustomerAddressBuilder.Verify(x => x.From(It.IsAny<CustomerCreateCommand>()));
        }
        public void Create_ValidCommand_Save_Special_If_Customer_Platinum()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var mockCustomerRepository = new Mock <ICustomerRepository>();
            var mockSatusFactory       = new Mock <IStatusFactory>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny <Customer>()));
            mockSatusFactory.Setup(x => x.From(It.IsAny <CustomerCreateCommand>()))
            .Returns(CustomerStatusEnum.Platinum);

            CustomerService_7 customerService = new CustomerService_7(
                mockCustomerRepository.Object,
                mockSatusFactory.Object
                );

            //Act
            customerService.Create(createCommmand);

            //Assert
            mockCustomerRepository.Verify(x => x.SaveSpecial(It.IsAny <Customer>()));

            //Practice: Test the other method..
            //QUESTION: How to verify that the other method is not called.
        }
        public void Verify_That_MailingAddress_Is_Get_From_customerAddressBuilder()
        {
            // Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var mockedCustomerRepository = new Mock <ICustomerRepository>();
            var mockedMailingFactory     = new Mock <IMailingAddressFactory>()
            {
                DefaultValue = DefaultValue.Mock
            };

            var customerService = new CustomerService_91(mockedCustomerRepository.Object, mockedMailingFactory.Object);

            ICustomerAddressBuilder customerAddressBuilder =
                mockedMailingFactory.Object.GetAddressBuilder(true);

            var mockedCustomerAddressBuilder = Mock.Get <ICustomerAddressBuilder>(customerAddressBuilder);

            // Act
            customerService.Create(createCommmand);

            // Assert
            mockedCustomerAddressBuilder.Verify(x => x.From(It.IsAny <CustomerCreateCommand>()));
        }
        public void CreateAssignedWorkStation_ValidCommand_Verify_WorkStationId_Get_From_ApplicationSettings_Using_Setup_Property()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockCustomerRepository = new Mock<ICustomerRepository>();
            var mockApplicationSettings = new Mock<IApplicationSettings>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny<Customer>()));
            //mockApplicationSettings.Setup(x => x.WorkStationId)
            //    .Returns(10);

            mockApplicationSettings.SetupProperty(x => x.WorkStationId, 123);

            //Can we set if from the object itself??
            //mockApplicationSettings.Object.WorkStationId = 345;

            //mockApplicationSettings.SetupAllProperties();

            CustomerService_8 customerService = new CustomerService_8(
                mockCustomerRepository.Object,
                mockApplicationSettings.Object
                );

            //Act
            customerService.CreateAssignedWorkStation(createCommmand);

            //Assert
            mockApplicationSettings.VerifyGet(x => x.WorkStationId);
        }
        public void Create_ValidCommand_Verfiy_Full_Name_Factory_Called_With_Valid_Parameters()
        {
            // Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockCustomerRepository = new Mock<ICustomerRepository>();
            var mockFullNameFactory = new Mock<IFullNameFactory>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny<Customer>()));
            mockFullNameFactory.Setup(x=> x.From(It.IsAny<string>(), It.IsAny<string>()));

            CustomerService_6 customerService = new CustomerService_6(mockCustomerRepository.Object,
                mockFullNameFactory.Object);
            // Act

            customerService.Create(createCommmand);

            // Assert
            mockFullNameFactory.Verify(
                x => x.From(
                    It.Is<string>(fn => fn.Equals(createCommmand.FirstName)),
                    It.Is<string>(fn => fn.Equals(createCommmand.LastName))
                    )
                );
        }
Example #10
0
        public void Create_ValidCommand_Verify_Timezone_Is_Set()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var mockCustomerRepository  = new Mock <ICustomerRepository>();
            var mockApplicationSettings = new Mock <IApplicationSettings>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny <Customer>()));

            CustomerService_8 customerService = new CustomerService_8(
                mockCustomerRepository.Object,
                mockApplicationSettings.Object
                );

            //Act
            customerService.Create(createCommmand);

            //Assert
            mockCustomerRepository.VerifySet(x => x.TimeZone = It.IsAny <string>());
        }
Example #11
0
        public void Create_ValidCommand_Verfiy_Full_Name_Factory_Called_With_Valid_Parameters()
        {
            // Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var mockCustomerRepository = new Mock <ICustomerRepository>();
            var mockFullNameFactory    = new Mock <IFullNameFactory>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny <Customer>()));
            mockFullNameFactory.Setup(x => x.From(It.IsAny <string>(), It.IsAny <string>()));

            CustomerService_6 customerService = new CustomerService_6(mockCustomerRepository.Object,
                                                                      mockFullNameFactory.Object);

            // Act

            customerService.Create(createCommmand);

            // Assert
            mockFullNameFactory.Verify(
                x => x.From(
                    It.Is <string>(fn => fn.Equals(createCommmand.FirstName)),
                    It.Is <string>(fn => fn.Equals(createCommmand.LastName))
                    )
                );
        }
        public void CreateAssignedWorkStation_ValidCommand_Verify_WorkStationId_Get_From_ApplicationSettings()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockCustomerRepository = new Mock<ICustomerRepository>();
            var mockApplicationSettings = new Mock<IApplicationSettings>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny<Customer>()));
            mockApplicationSettings.Setup(x => x.WorkStationId)
                .Returns(10);

            CustomerService_8 customerService = new CustomerService_8(
                mockCustomerRepository.Object,
                mockApplicationSettings.Object
                );

            //Act
            customerService.CreateAssignedWorkStation(createCommmand);

            //Assert
            mockApplicationSettings.VerifyGet(x => x.WorkStationId);
        }
        public void Create_ValidCommand_Client_Should_Be_Persisted()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            MailingAddress mailingAddress = new MailingAddress() { Street = "Test Street", StreetNumber = 10 };

            var mockRepository = new Mock<ICustomerRepository>();
            var mockMailingAddressFactory = new Mock<IMailingAddressFactory>();

            mockRepository.Setup(x => x.Save(It.IsAny<Customer>()));

            mockMailingAddressFactory.Setup(x => x.TryParse(It.IsAny<string>(), out mailingAddress))
                .Returns(true);

            CustomerService_4 customerService = new CustomerService_4(mockMailingAddressFactory.Object, mockRepository.Object);
            //Act
            customerService.Create(createCommmand);

            //Assert
            mockRepository.Verify(x => x.Save(It.IsAny<Customer>()));
        }
Example #14
0
        public void IF_name_is_not_provided_SHOULD_throw()
        {
            //Arrange
            var command = new CustomerCreateCommand();

            //Act
            var exception = Assert.ThrowsAsync <HttpResponseException>(async() => await Sut.CreateAsync(command));

            //Assert
            Assert.That(exception !.Message, Is.EqualTo("BadRequest: An customer name is required."));
        }
Example #15
0
        public void Test()
        {
            CustomerCreateCommand command = new CustomerCreateCommand();

            _commandBus.Send(command);

            CommandResultQuery<CustomerCreateCommandResult> query = new CommandResultQuery<CustomerCreateCommandResult>(command);

            CustomerCreateCommandResult result = _queryBus.Send(query);

            int id = result.CustomerId;
        }
Example #16
0
        public async Task <IActionResult> GetAll(CancellationToken ct)
        {
            CustomerCreateCommand cmd = new CustomerCreateCommand()
            {
                FirstName = "Bruno"
            };

            await _manualHandler.Handle(cmd, ct);

            var response = await _mediator.Send(cmd);

            return(Ok(response));
        }
Example #17
0
        public void IF_name_already_exists_SHOULD_throw()
        {
            //Arrange
            var command = new CustomerCreateCommand
            {
                Name = "Limited access customer"
            };

            //Act
            var exception = Assert.ThrowsAsync <HttpResponseException>(async() => await Sut.CreateAsync(command));

            //Assert
            Assert.That(exception !.Message, Is.EqualTo("BadRequest: Duplicate active customer with name is not allowed."));
        }
Example #18
0
        public async Task IF_only_name_is_provided_SHOULD_create_with_default_values()
        {
            try
            {
                //Arrange
                var customer = new CustomerCreateCommand
                {
                    Name = "Name Only Customer"
                };

                //Act
                var result = await Sut.CreateAsync(customer);

                //Assert
                Assert.That(result.Id, Is.GreaterThan(1));
                Assert.That(result.Name, Is.EqualTo("Name Only Customer"));
                Assert.That(result.CreatedAt.Date, Is.EqualTo(DateTime.UtcNow.Date));
                Assert.That(result.ModifiedAt, Is.EqualTo(result.CreatedAt));
                Assert.That(result.BillingAddress1, Is.EqualTo(""));
                Assert.That(result.BillingAddress2, Is.EqualTo(""));
                Assert.That(result.BillingPostalCode, Is.EqualTo(""));
                Assert.That(result.BillingCity, Is.EqualTo(""));
                Assert.That(result.BillingState, Is.EqualTo(""));
                Assert.That(result.BillingCountry, Is.EqualTo(""));
                Assert.That(result.ShippingAddress1, Is.EqualTo(""));
                Assert.That(result.ShippingAddress2, Is.EqualTo(""));
                Assert.That(result.ShippingPostalCode, Is.EqualTo(""));
                Assert.That(result.ShippingCity, Is.EqualTo(""));
                Assert.That(result.ShippingState, Is.EqualTo(""));
                Assert.That(result.ShippingCountry, Is.EqualTo(""));
                Assert.That(result.Comment, Is.EqualTo(""));
                Assert.That(result.IsTaxable, Is.EqualTo(true));
                Assert.That(result.TaxNumber, Is.EqualTo(""));
                Assert.That(result.Email, Is.EqualTo(""));
                Assert.That(result.ExternalKey, Is.EqualTo(""));
                Assert.That(result.Latitude, Is.EqualTo(null));
                Assert.That(result.Longitude, Is.EqualTo(null));
            }
            finally
            {
                //Cleanup
                var testCreatedCustomers = await Sut.SearchAsync(new CustomerSearchCommand { Query = "Name Only Customer" });

                foreach (var customerDto in testCreatedCustomers.Results)
                {
                    await Sut.DeleteAsync(customerDto.Id);
                }
            }
        }
Example #19
0
        public async Task <IActionResult> CreateAsync(CustomerCreateCommand command)
        {
            /* ModeState validation is automatic with ApiController
             * but I need this to replicate bad request status in my unit case. */
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var entryId = await _mediator.Send(command);

            return(CreatedAtRoute(
                       "CustomerGetById",
                       new { id = entryId },
                       null
                       ));
        }
        public void Create_ValidMailAddress_ShouldSave()
        {
            // Arrange
            var createCommmand = new CustomerCreateCommand() {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var customerAddressBuilder = new MockedCustomerAddressBuilder();
            var customerRepository = new MockedCustomerRepository();

            CustomerService_1 customerService = new CustomerService_1(customerAddressBuilder, customerRepository);

            // Act
            customerService.Create(createCommmand);

            // Assert
            Assert.IsTrue(customerRepository.IsSaveCalled);
        }
Example #21
0
        public void Create_ValidMailAddress_ShouldSave()
        {
            // Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var customerAddressBuilder = new MockedCustomerAddressBuilder();
            var customerRepository     = new MockedCustomerRepository();

            CustomerService_1 customerService = new CustomerService_1(customerAddressBuilder, customerRepository);

            // Act
            customerService.Create(createCommmand);

            // Assert
            Assert.IsTrue(customerRepository.IsSaveCalled);
        }
Example #22
0
        public async Task <ActionResult> Post([FromBody] CustomerCreateCommand command)
        {
            try
            {
                var response = await _customerService.Add(command);

                var notifications = _customerService as Notifiable;

                if (response == null && notifications.Error.Any())
                {
                    return(BadRequest(notifications.Error));
                }

                return(Created(string.Empty, response));
            }
            catch (Exception ex)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError, ex.ToString()));
            }
        }
        public void Create_ValidCreateCommand_CustomerServiceRepository_Should_be_Called()
        {
            // Arrange
            var createCommand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockedRepository = new Mock<ICustomerRepository>();
            mockedRepository.Setup(x=> x.Save(It.IsAny<Customer>()));

            CustomerService_2 customerService =
                new CustomerService_2(mockedRepository.Object);

            // Act
            customerService.Create(createCommand);

            // Assert
            mockedRepository.Verify(x => x.Save(It.IsAny<Customer>()));
        }
        public void Create_ValidCommand_If_Customer_Has_No_Mailing_Address()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockRepository = new Mock<ICustomerRepository>();
            var mockAddressBuilder = new Mock<ICustomerAddressBuilder>();

            mockRepository.Setup(x => x.Save(It.IsAny<Customer>()));
            mockAddressBuilder.Setup(x => x.From(It.IsAny<CustomerCreateCommand>()))
                .Returns(() => null);

            CustomerService_3 customerService = new CustomerService_3(mockAddressBuilder.Object, mockRepository.Object);
            //Act
            customerService.Create(createCommmand);

            //Assert
        }
        public void Create_ValidCreateCommand_CustomerServiceRepository_Should_be_Called()
        {
            // Arrange
            var createCommand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var mockedRepository = new Mock <ICustomerRepository>();

            mockedRepository.Setup(x => x.Save(It.IsAny <Customer>()));

            CustomerService_2 customerService =
                new CustomerService_2(mockedRepository.Object);

            // Act
            customerService.Create(createCommand);

            // Assert
            mockedRepository.Verify(x => x.Save(It.IsAny <Customer>()));
        }
Example #26
0
        public void Create_ValidCommand_If_Customer_Has_No_Mailing_Address()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var mockRepository     = new Mock <ICustomerRepository>();
            var mockAddressBuilder = new Mock <ICustomerAddressBuilder>();

            mockRepository.Setup(x => x.Save(It.IsAny <Customer>()));
            mockAddressBuilder.Setup(x => x.From(It.IsAny <CustomerCreateCommand>()))
            .Returns(() => null);

            CustomerService_3 customerService = new CustomerService_3(mockAddressBuilder.Object, mockRepository.Object);

            //Act
            customerService.Create(createCommmand);

            //Assert
        }
        public void Create_ValidCommand_Verify_That_Save_Is_Called()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockRepository = new Mock<ICustomerRepository>();
            var mockAddressBuilder = new Mock<ICustomerAddressBuilder>();

            mockRepository.Setup(x => x.Save(It.IsAny<Customer>()));
            mockAddressBuilder.Setup(x => x.From(It.IsAny<CustomerCreateCommand>()))
                .Returns("*****@*****.**");

            CustomerService_3 customerService = new CustomerService_3(mockAddressBuilder.Object, mockRepository.Object);
            //Act
            customerService.Create(createCommmand);

            //Assert
            mockRepository.Verify(x => x.Save(It.IsAny<Customer>()));
        }
Example #28
0
        public void Create_ValidCommand_Verify_That_Save_Is_Called()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName  = "Ahmed"
            };

            var mockRepository     = new Mock <ICustomerRepository>();
            var mockAddressBuilder = new Mock <ICustomerAddressBuilder>();

            mockRepository.Setup(x => x.Save(It.IsAny <Customer>()));
            mockAddressBuilder.Setup(x => x.From(It.IsAny <CustomerCreateCommand>()))
            .Returns("*****@*****.**");

            CustomerService_3 customerService = new CustomerService_3(mockAddressBuilder.Object, mockRepository.Object);

            //Act
            customerService.Create(createCommmand);

            //Assert
            mockRepository.Verify(x => x.Save(It.IsAny <Customer>()));
        }
        public async Task <IActionResult> Post(CustomerCreateCommand command)
        {
            var response = await _mediator.Send(command);

            return(Ok(response));
        }
 public async Task<CustomerResponse> Add(CustomerCreateCommand command)
 {
     var customer = await _mediator.Send(command);
     return _mapper.Map<Customer, CustomerResponse>(customer);
 }
Example #31
0
 public string From(CustomerCreateCommand customercommand)
 {
     return(string.Format("{0}.{1}@itworx.com", customercommand.FirstName,
                          customercommand.LastName));
 }
Example #32
0
        public async Task <IActionResult> Post([FromBody] CustomerCreateCommand command)
        {
            var id = await _mediator.Send(command);

            return(await Get(id));
        }
        public void Create_ValidCommand_Verify_Timezone_Is_Set()
        {
            //Arrange
            var createCommmand = new CustomerCreateCommand()
            {
                FirstName = "Mohamed",
                LastName = "Ahmed"
            };

            var mockCustomerRepository = new Mock<ICustomerRepository>();
            var mockApplicationSettings = new Mock<IApplicationSettings>();

            mockCustomerRepository.Setup(x => x.Save(It.IsAny<Customer>()));

            CustomerService_8 customerService = new CustomerService_8(
                mockCustomerRepository.Object,
                mockApplicationSettings.Object
                );

            //Act
            customerService.Create(createCommmand);

            //Assert
            mockCustomerRepository.VerifySet(x => x.TimeZone = It.IsAny<string>());
        }
Example #34
0
        public async Task IF_command_is_valid_SHOULD_create()
        {
            try
            {
                //Arrange
                var customer = new CustomerCreateCommand
                {
                    Name               = "Test Create Customer",
                    BillingAddress1    = "B1",
                    BillingAddress2    = "B2",
                    BillingPostalCode  = "B3",
                    BillingCity        = "B4",
                    BillingState       = "B5",
                    BillingCountry     = "B6",
                    ShippingAddress1   = "S1",
                    ShippingAddress2   = "S2",
                    ShippingPostalCode = "S3",
                    ShippingCity       = "S4",
                    ShippingState      = "S5",
                    ShippingCountry    = "S6",
                    Comment            = "No comment",
                    IsTaxable          = true,
                    TaxNumber          = "Tax",
                    Email              = "email",
                    ExternalKey        = "123",
                    GpsCoordinates     = "1, 2.1"
                };

                //Act
                var result = await Sut.CreateAsync(customer);

                //Assert
                Assert.That(result.Id, Is.GreaterThan(1));
                Assert.That(result.Name, Is.EqualTo("Test Create Customer"));
                Assert.That(result.CreatedAt.Date, Is.EqualTo(DateTime.UtcNow.Date));
                Assert.That(result.ModifiedAt, Is.EqualTo(result.CreatedAt));
                Assert.That(result.BillingAddress1, Is.EqualTo("B1"));
                Assert.That(result.BillingAddress2, Is.EqualTo("B2"));
                Assert.That(result.BillingPostalCode, Is.EqualTo("B3"));
                Assert.That(result.BillingCity, Is.EqualTo("B4"));
                Assert.That(result.BillingState, Is.EqualTo("B5"));
                Assert.That(result.BillingCountry, Is.EqualTo("B6"));
                Assert.That(result.ShippingAddress1, Is.EqualTo("S1"));
                Assert.That(result.ShippingAddress2, Is.EqualTo("S2"));
                Assert.That(result.ShippingPostalCode, Is.EqualTo("S3"));
                Assert.That(result.ShippingCity, Is.EqualTo("S4"));
                Assert.That(result.ShippingState, Is.EqualTo("S5"));
                Assert.That(result.ShippingCountry, Is.EqualTo("S6"));
                Assert.That(result.Comment, Is.EqualTo("No comment"));
                Assert.That(result.IsTaxable, Is.EqualTo(true));
                Assert.That(result.TaxNumber, Is.EqualTo("Tax"));
                Assert.That(result.Email, Is.EqualTo("email"));
                Assert.That(result.ExternalKey, Is.EqualTo("123"));
                Assert.That(result.Latitude, Is.EqualTo(1));
                Assert.That(result.Longitude, Is.EqualTo(2.1f));
            }
            finally
            {
                //Cleanup
                var testCreatedCustomers = await Sut.SearchAsync(new CustomerSearchCommand { Query = "Test Create Customer" });

                foreach (var customerDto in testCreatedCustomers.Results)
                {
                    await Sut.DeleteAsync(customerDto.Id);
                }
            }
        }
        public async Task <IActionResult> Create([FromBody] CustomerCreateCommand command)
        {
            var model = await _mediator.Send(command);

            return(CreatedAtAction(nameof(Create), new { model.Id }, model));
        }
 public async Task <CustomerDto> CreateAsync(CustomerCreateCommand command, CancellationToken token = default)
 {
     return(await PostAsync(command, "", token));
 }
 public string From(CustomerCreateCommand customercommand)
 {
     return string.Format("{0}.{1}@itworx.com", customercommand.FirstName,
         customercommand.LastName);
 }