The HttpClient instance already started one or more requests. Properties can only be modified before sending the first request.

You have fallen foul of a little WCF Web Api gotcha. Message handlers need to be created each time they are required. I was using Castle Windsor to handle the lifetime of my message handlers

    public class MessageHandlerInstaller : IWindsorInstaller
    {
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            var path = Assembly.GetExecutingAssembly().GetDirectoryName();
            var filter = new AssemblyFilter(path, "ByBox*.dll");

            container.Register(
                AllTypes
                    .FromAssemblyInDirectory(filter)
                    .Where(t => t.IsSubclassOf(typeof (DelegatingHandler)))
                    .Configure(c => c.LifeStyle.Custom(InstallerContext.LifestyleManager))
                );
        }
    }

So, I’m using my InstallerContext’s lifestyle, but what I actually needed was this …

                    .Configure(c => c.LifeStyle.Transient)

I found this in a discussion on the wcf codeplex site

[TestCase(0, "Forename", "Antony")]
[TestCase(0, "Surname", "Scott")]
[TestCase(0, "TwitterUserName", "antony_scott")]
public void ExampleTest(int index, string fieldname, object expectedValue)
{
    var result = GetPersonDetails();
    var list = result.ToList();
    Assert.IsFieldEqual(list.ElementAt(index), fieldname, expectedValue);
}

This gives me a very compact and easy to understand test with great visibility of any fields which are being pulled from the database correctly. All this is nothing new, as I’ve blogged about it previously here.

What I’ve added is the ability to dig into a structure like so …

[TestCase(0, "Forename", "Antony")]
[TestCase(0, "Surname", "Scott")]
[TestCase(0, "Twitter.UserName", "antony_scott")]
public void ExampleTest(int index, string fieldname, object expectedValue)
{
    var result = GetPersonDetails();
    var list = result.ToList();
    Assert.IsFieldEqual(list.ElementAt(index), fieldname, expectedValue);
}

In case you can’t see any difference, it’s the “dot” in the 3rd test case.

Here is the “extension” of the Assert class which makes it possible …

    public class Assert : NUnit.Framework.Assert
    {
        public static void IsFieldEqual(object obj, string propertyName, object expectedValue)
        {
            var type = obj.GetType();

            var dotIndex = propertyName.IndexOf('.');
            if (dotIndex != -1)
            {
                var innerObjName = propertyName.Substring(0, dotIndex);
                var innerPropName = propertyName.Substring(dotIndex + 1);
                var innerProp = type.GetProperty(innerObjName);
                var innerObj = innerProp.GetValue(obj, null);
                IsFieldEqual(innerObj, innerPropName, expectedValue);
            }
            else
            {
                var prop = type.GetProperty(propertyName);
                var actualValue = prop.GetValue(obj, null);
                AreEqual(expectedValue, actualValue);
            }
        }
    }

using Newtonsoft.Json.Schema;

var jsonSchemaGenerator = new JsonSchemaGenerator();
var myType = typeof(MyClass);
var schema = jsonSchemaGenerator.Generate(myType);
schema.Title = myType.Name; // this doesn't seem to get done within the generator

then write it to a file …

var writer = new StringWriter();
var jsonTextWriter = new JsonTextWriter(writer);
schema.WriteTo(jsonTextWriter);
var prettyString = JsonPrettifier.Prettify(writer.ToString());
var fileWriter = new StreamWriter("MySchema.txt");
fileWriter.WriteLine(schema.Title);
fileWriter.WriteLine(new string('-', schema.Title.Length));
fileWriter.WriteLine(prettyString);
fileWrite.Close();

What took me a while to figure out was that MyClass needs to be decorated with specific attributes in order for the schema to be correctly generated.

public class MyClass
{
    [JsonProperty(Required = Required.Always)]
    public string Forename { get; set; }

    [JsonProperty(Required = Required.Always)]
    public string Surname { get; set; }

    [JsonProperty(Required = Required.Always)]
    public string EmailAddress { get; set; }

    [JsonProperty(Required = Required.AllowNull)]
    public string MobilePhoneNumber { get; set; }
}

So, the JsonProperty attribute is your friend here! I took my a while to figure out, including some time stepping through the Json.NET source code in the debugger.

public class Assert : NUnit.Framework.Assert
{
    public static void IsFieldEqual(object obj, string propertyName, object expectedValue)
    {
        var type = obj.GetType();
        var prop = type.GetProperty(propertyName);
        var actualValue = prop.GetValue(obj, null);
        AreEqual(expectedValue, actualValue);
    }
}

This allows me to write tests to check the value of each field in a result object and have the assert fail on the specific field, it also doesn’t stop the other field being tested. So, using the TestCase attribute I can write tests such as this …

[TestCase("Forename", "Antony")]
[TestCase("Surname", "Scott")]
public void example_test(string fieldname, object expectedValue)
{
    // Arrange
    Context.AddPerson(new Person { ID = 1, Forename = "Antony", Surname = "Scott" });

    // Act
    var result = Service.GetPerson(1);

    // Assert
    Assert.IsFieldEqual(result, fieldname, expectedValue);
}

Obviously this is an over-simplified example. But, the idea is that I can now have a complex object being loaded up by an integration test into my database. I then use a Service of some kind (what I’m testing) to query my database and I can then make sure all the correct details have been retrieved from the database.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Net.Http;
using ByBox.WebApi.HttpResponseMessages;
using Microsoft.ApplicationServer.Http.Dispatcher;

namespace WhateverYouWant
{
    public class ValidationHandler<TResource> : HttpOperationHandler<TResource, HttpRequestMessage, HttpRequestMessage>
    {
        public ValidationHandler() : base("response") { }

        protected override HttpRequestMessage OnHandle(TResource model, HttpRequestMessage requestMessage)
        {
            var results = new List<ValidationResult>();
            var context = new ValidationContext(model, null, null);
            Validator.TryValidateObject(model, context, results, true);

            if (results.Count == 0)
            {
                return requestMessage;
            }

            var errorMessages = results.Select(x => x.ErrorMessage).ToArray();

            var mediaType = requestMessage.Headers.Accept.FirstOrDefault();
            var response = new RestValidationFailure(errorMessages);
            if (mediaType != null)
            {
                response.Content = new ObjectContent(typeof(string[]), errorMessages, mediaType);
            }
            throw new HttpResponseException(response);
        }
    }
}

What I added to the answer on stack overflow was the ability to return a list of error messages in both the headers and the body of the response. The list of errors in the body are sent in the format the browser will “accept”. This helps keep everything simple on the client side. I have only checked if it works for xml and json. For the sake of completeness I have included a version of my RestValidationFailure class.

using System.Net.Http;

namespace WhateverYouWant
{
    public class RestValidationFailure : HttpResponseMessage
    {
        public RestValidationFailure(string[] errorMessages)
        {
            StatusCode = HttpStatusCode.BadRequest;
            foreach (var errorMessage in errorMessages)
            {
                Headers.Add("X-Validation-Error", errorMessage);
            }
        }
    }
}

From my Application_Start() method I call a ConfigureApi(RouteCollection routes) method. This create the config object and then sets up any routes …

    private static void ConfigureApi(RouteCollection routes)
    {
        Container = CreateContainer();

        var config = new MyApiConfiguration(Container);
        routes.SetDefaultHttpConfiguration(config);

        routes.MapServiceRoute<MyApi>("myresource");
    }

I then set up CreateInstance, ErrorHandlers, and MessageHandlerFactory with anonymous methods which simply call the relevant Resolve methods on my container.

public class MyApiConfiguration : WebApiConfiguration
{
    public MyApiConfiguration(IWindsorContainer container)
    {
        EnableTestClient = GetSetting("TestClient");
        IncludeExceptionDetail = GetSetting("IncludeExceptionDetail");

        CreateInstance = ((serviceType, context, request) => container.Resolve(serviceType));
        ErrorHandlers = (handlers, endpoint, description) => handlers.Add(container.Resolve<GlobalErrorHandler>());
        MessageHandlerFactory = () => container.ResolveAll<DelegatingHandler>();

        this.ValidateAllResourceTypes();
    }

    private static bool GetSetting(string settingName)
    {
        bool flag;
        bool.TryParse(ConfigurationManager.AppSettings[settingName] ?? "false", out flag);
        return flag;
    }
}

And that’s all there is to it. Simple really.

ValidateAllResourceTypes is something I will blog about another time. It uses reflection to register all resource types for validation via data annotations.

    private DomainContext _context;
    protected DomainContext Context
    {
        get { return _context ?? (_context = new DomainContext(ConfigurationManager.ConnectionStrings["ByBox"].ConnectionString)); }
        private set { _context = value; }
    }

    private ConsumerRepository _repository;
    private ConsumerRepository Repository
    {
        get { return _repository ?? (_repository = new ConsumerRepository(Context)); }
        set { _repository = value; }
    }

Then I have some straight forward setup/teardown code. All this usually ends up in a base class of some kind which I re-use in all my different test source files.

    [TestFixtureSetUp]
    public virtual void TestFixtureSetUp()
    {
        try
        {
            var seed = new DomainDataSeed();
            Database.SetInitializer(seed);
            Context.Database.Initialize(true);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
            throw;
        }
    }

    [TestFixtureTearDown]
    public virtual void TestFixtureTearDown()
    {
        Repository.Dispose();
        Repository = null;
        Context.Dispose();
        Context = null;
    }

Another useful thing to do is to be able to reset the database to a know state. You may have noticed these 3 lines above …

            var seed = new DomainDataSeed();
            Database.SetInitializer(seed);
            Context.Database.Initialize(true);

What these do is use a data seed class to initialise the database. By way of example, here is a snippet from my seed class …

    public class DomainDataSeed : DropCreateDatabaseAlways<DomainContext>
    {
        protected override void Seed(DomainContext context)
        {
            AddWebServiceUsers(context);
            AddUserAccounts(context);

            context.SaveChanges();
        }

        private void AddWebServiceUsers(DomainContext context)
        {
            context.Database.ExecuteSqlCommand("CREATE TABLE [web_service_user] ( ... )");
            context.Database.ExecuteSqlCommand("CREATE TABLE [web_service_user_attribute] ( ... )");
            context.Database.ExecuteSqlCommand("INSERT INTO [web_service_user] ([username], [password]) values({0}, {1})", Username, Password);
        }
        private static void AddUserAccounts(DomainContext context)
        {
            context.UserAccounts.Add(
                new UserAccount
                    {
                        ...
                    });
        }
    }

If I wanted to I could put that code into the [SetUp] method rather than the [TestFixtureSetUp] method. Or, as I have done recently in a ResetDatabase() method, which I call from the [TestFixtureSetUp] and select tests as required. This particular seed class drops and re-creates the database every time it is called, thanks to this – DropCreateDatabaseAlways<DomainContext>. There are other options available, including only dropping and re-creating the database (and seeding it) when the model changes.

    public void validation_failure_identifier_null_400_expected()
    {
        // Arrange
        var resource = CreateCompleteResource();
        resource.Identifier = null;
        var jsonString = JsonPrettifier.Prettify(resource);

        // Act
        var result = Service.Post(jsonString);

        // Assert
        result.Message.CheckForValidationError("Identifier");
    }

    public void validation_failure_forename_null_400_expected()
    {
        // Arrange
        var resource = CreateCompleteResource();
        resource.Forename = null;
        var jsonString = JsonPrettifier.Prettify(resource);

        // Act
        var result = Service.Post(jsonString);

        // Assert
        result.Message.CheckForValidationError("Forename");
    }

… and so on.

BUT, by using a little reflection in conjunction with the [TestCase] attribute of NUnit, I can do this …

    private string GenerateJsonAndSetFieldTo(string fieldName, string value)
    {
        var resource = CreateCompleteResource();
        var type = resource.GetType();
        var prop = type.GetProperty(fieldName);
        prop.SetValue(resource, value, new object[0]);
        var jsonString = JsonPrettifier.Prettify(resource);
        return jsonString;
    }

    [TestCase("Identifier")]
    [TestCase("Forename")]
    public void validation_failure_400_expected(string fieldName)
    {
        // Arrange
        var jsonString = GenerateJsonAndSetFieldTo(fieldName, null);

        // Act
        var result = Service.Post(jsonString);

        // Assert
        result.Message.CheckForValidationError(fieldName);
    }

Obviously I have more TestCase’s than shown here, I didn’t want to bore you all with them! Less tests to maintain, easier to add null checking for other fields and it also looks neater in my test runner of choice.

using System;
using System.Collections.Generic;
using System.ComponentModel.Composition.Hosting;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration;
using System.IO;
using System.Linq;
using System.Reflection;

namespace Base.EntityFramework
{
    public abstract class BaseDbContext : DbContext
    {
        protected BaseDbContext() { }
        protected BaseDbContext(string connectionString) : base(connectionString) { }

        private IEnumerable<Type> GetTypes()
        {
            var type = typeof(EntityTypeConfiguration<>);
            return GetType()
                .GetProperties(BindingFlags.Instance | BindingFlags.Public)
                .Where(p => p.PropertyType.IsGenericType &&
                            p.PropertyType.GetGenericTypeDefinition() == typeof(IDbSet<>))
                .Select(p => type.MakeGenericType(p.PropertyType.GetGenericArguments().First()))
                .ToArray();
        }

        private static void LoadAllEntityConfigurationsFromAllAssemblies(DbModelBuilder modelBuilder, IEnumerable<Type> types, string assemblyFilter, IEnumerable<string> namePartFilters)
        {
            var path = Path.GetDirectoryName((new Uri(Assembly.GetExecutingAssembly().CodeBase)).AbsolutePath);
            new DirectoryCatalog(path, assemblyFilter)
                .LoadedFiles
                .Where(x =>
                {
                    var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(x.ToLower());
                    if (fileNameWithoutExtension != null)
                    {
                        var parts = fileNameWithoutExtension.Split(".".ToCharArray());
                        return parts.Any(part => namePartFilters.Any(namePartFilter => part == namePartFilter.ToLower()));
                    }
                    return false;
                })
                .Select(Assembly.LoadFrom)
                .ToList()
                .ForEach(assembly => assembly.GetTypes()
                                         .Where(t => types.Contains(t.BaseType))
                                         .Select(Activator.CreateInstance)
                                         .ToList<dynamic>()
                                         .ForEach(instance => modelBuilder.Configurations.Add(instance)));
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            var typesToLoad = GetTypes();
            LoadAllEntityConfigurationsFromAllAssemblies(modelBuilder, typesToLoad, "*.dll", new[] { "Data", "Domain" });
        }

    }
}

and in english ….

1. Discover which classes for which I need to find and load the relevant EntityTypeConfiguration<> class. This is done with a little bit of reflection in the GetTypes() method.
2. Use MEF to find the assemblies the config classes might be in. In this case it’s all of them (*.dll), but that could be changed to whatever is best for your situation.
3. Use the namePartFilters to narrow down the list of assemblies further. In this case I’m looking for anything with “Data” or “Domain” in the filename (after it’s been split by periods).
4. Load each assembly.
5. Load any generic EntityTypeConfiguration types for the model classes used within my context class (the one which is derived from this base class).
6. Instantiate each config class.
7. Add it to the modelBuilder’s configurations.

Since this is a base class I can get this behaviour whenever I derive from it ….

    public class DomainContext : BaseDbContext, IDomainContext
    {
        public IDbSet<Employee> Employees { get; set; }

        public DomainContext() { }
        public DomainContext(string connectionString) : base(connectionString) { }

        IQueryable<Employee> IDomainContext.Employees { get { return Employees; } }
    }

What this allows me to do is use models from any assembly I am referencing in my application and just add it to my Context. Any configuration class for it will then be automatically added to the model builder.

If you are 40, or older, you might think this is hilarious!

When I was a kid, adults used to bore me to tears with their tedious
diatribes about how hard things were. When they were growing up; what with
walking twenty-five miles to school every morning…. Uphill… Barefoot…
BOTH ways. yadda, yadda, yadda

And I remember promising myself that when I grew up, there was no way in
hell I was going to lay a bunch of crap like that on my kids about how hard
I had it and how easy they’ve got it!

But now that I’m over the ripe old age of forty, I can’t help but look
around and notice the youth of today You’ve got it so easy! I mean,
compared to my childhood, you live in a damn Utopia!
And I hate to say it, but you kids today, you don’t know how good you’ve got it!

1. I mean, when I was a kid we didn’t have the Internet. If we wanted to
   know something, we had to go to the damn library and look it up ourselves,
   in the card catalog!!
2. There was no email!! We had to actually write somebody a letter – with a
   pen! Then you had to walk all the way across the street and put it in the
   mailbox, and it would take like a week to get there! Stamps were 10 cents!
3. Child Protective Services didn’t care if our parents beat us. As a
   matter of fact, the parents of all my friends also had permission to kick
   our ass! Nowhere was safe!
4. There were no MP3′s or Napsters or iTunes! If you wanted to steal music,
   you had to hitchhike to the record store and shoplift it yourself!
5. Or you had to wait around all day to tape it off the radio, and the DJ
   would usually talk over the beginning and @#*% it all up! There were no CD
   players! We had tape decks in our car. We’d play our favorite tape and
   “eject” it when finished, and then the tape would come undone rendering it
   useless. Cause, hey, that’s how we rolled, Baby! Dig?
6. We didn’t have fancy crap like Call Waiting! If you were on the phone
   and somebody else called, they got a busy signal, that’s it!
7. There weren’t any freakin’ cell phones either. If you left the house, you
   just didn’t make a damn call or receive one. You actually had to be out of
   touch with your “friends”. OH MY GOSH !!! Think of the horror… not being
   in touch with someone 24/7!!! And then there’s TEXTING. Yeah, right.
   Please! You kids have no idea how annoying you are.
8. And we didn’t have fancy Caller ID either! When the phone rang, you had
   no idea who it was! It could be your school, your parents, your boss, your
   bookie, your drug dealer, the collection agent… you just didn’t know!!!
   You had to pick it up and take your chances, mister!
9. We didn’t have any fancy PlayStation or Xbox video games with
   high-resolution 3-D graphics! We had the Atari 2600! With games like
   ‘Space Invaders’ and ‘Asteroids’. Your screen guy was a little square! You
   actually had to use your imagination!!! And there were no multiple levels
   or screens, it was just one screen… Forever! And you could never win.
   The game just kept getting harder and harder and faster and faster until you
   died! Just like LIFE!
10. You had to use a little book called a TV Guide to find out what was on!
    You were screwed when it came to channel surfing! You had to get off your
    ass and walk over to the TV to change the channel!!! NO REMOTES!!! Oh, no,
    what’s the world coming to?!?!
11. There was no Cartoon Network either! You could only get cartoons on
    Saturday Morning. Do you hear what I’m saying? We had to wait ALL WEEK for
    cartoons, you spoiled little rat-bastards!
12. And we didn’t have microwaves. If we wanted to heat something up, we
    had to use the stove! Imagine that!
13. And our parents told us to stay outside and play… all day long. Oh,
    no, no electronics to soothe and comfort. And if you came back inside…
    you were doing chores!
14. And car seats – oh, please! Mom threw you in the back seat and you hung on.
    If you were lucky, you got the “safety arm” across the chest at the last
    moment if she had to stop suddenly, and if your head hit the dashboard, well
    that was your fault for calling “shot gun” in the first place!

See! That’s exactly what I’m talking about! You kids today have got it too
easy. You’re spoiled rotten! You guys wouldn’t have lasted five minutes
back in 1970 or any time before!

Regards,
The Over 40 Crowd

Received via email from my Dad today!