public async Task QueryMultipleMessagesTypesOfSpecificResourceType()
        {
            //lets create customer first to ensure message created
            await WithCustomer(client, DefaultCustomerDraftWithAddress, async customer =>
            {
                Assert.Single(customer.Addresses);
                var oldAddress = customer.Addresses[0];
                //then change his address
                var newAddress = TestingUtility.GetRandomAddress();

                var updateActions = new List <UpdateAction <Customer> >();
                var action        = new ChangeAddressUpdateAction()
                {
                    Address = newAddress, AddressId = oldAddress.Id
                };
                updateActions.Add(action);

                var updatedCustomer = await client
                                      .ExecuteAsync(new UpdateByIdCommand <Customer>(customer, updateActions));


                var queryCommand = new QueryCommand <Message <Customer> >();
                queryCommand.Where(message => message.Resource.Id == customer.Id.valueOf());

                await AssertEventuallyAsync(async() =>
                {
                    //Act
                    var returnedSet = await client.ExecuteAsync(queryCommand);

                    //Assert
                    Assert.Equal(2, returnedSet.Results.Count);

                    var customerCreatedMessage =
                        returnedSet.Results.OfType <CustomerCreatedMessage>().FirstOrDefault();
                    var customerAddressChangedMessage =
                        returnedSet.Results.OfType <CustomerAddressChangedMessage>().FirstOrDefault();

                    Assert.NotNull(customerCreatedMessage);
                    Assert.NotNull(customerCreatedMessage.Customer);
                    Assert.Equal(customer.Id, customerCreatedMessage.Customer.Id);
                    Assert.NotNull(customerAddressChangedMessage);
                    Assert.NotNull(customerAddressChangedMessage.Address);
                    Assert.Equal(updatedCustomer.Addresses[0].Id, customerAddressChangedMessage.Address.Id);
                }
                                            );
            });
        }
        public async Task UpdateCustomerChangeAddress()
        {
            await WithUpdateableCustomer(client, DefaultCustomerDraftWithAddress, async customer =>
            {
                Assert.Single(customer.Addresses);
                var address = TestingUtility.GetRandomAddress();
                var action  = new ChangeAddressUpdateAction {
                    Address = address, AddressId = customer.Addresses[0].Id
                };

                var updatedCustomer = await client
                                      .ExecuteAsync(customer.UpdateById(actions => actions.AddUpdate(action)));


                Assert.Equal(address.ToString(), updatedCustomer.Addresses[0].ToString());
                return(updatedCustomer);
            });
        }