<p>A simple update of an object is as complex as adding a new instance of the object, which means it is both straight forward and laden with all kinds of caveats and unlying processes. As with <a href="/posts/2016/user-can-create-new-patron/">creating a new Patron</a>, it is trivial for me to put together a contrived example of code that will technically satisfy the requirements for "User Can Update a Patron". A unit Test will create a new Command that will be validated by the Factory and then passed to the MessageQueue for persistance by some other process.</p>
<h2>Command and Tests</h2>
<p>There is no surprising code here. The only differences, at this point, between the <code>CreatePatronCommand</code> and the <code>UpdatePatronCommand</code> is the removal of any fields being required and the addition of an <code>IKeyIdentity</code> identifier.</p>
<pre><code class="language-csharp">using System.ComponentModel.DataAnnotations;
using Vigil.Domain;

namespace Vigil.MessageQueue.Commands
{
    public class UpdatePatronCommand : ICommand
    {
        [Required]
        public IKeyIdentity TargetPatron { get; set; }

        [StringLength(250)]
        public string DisplayName { get; set; }
        public bool? IsAnonymous { get; set; }
        [StringLength(250)]
        public string PatronType { get; set; }
    }
}
</code></pre>
<p>The intent is that further down the line, the process that actually performs the update will ignore any fields that are <em>null</em>. I am partial to the idea of only passing data that actually needs changing. In the future, when I need to handle non-nullable data, then I will worry about how to indicate a removal of information. At this point, though, it is tomorrow-David's problem.</p>
<p>The <code>IKeyIdentity</code> is for the issuing code to indicate which entity needs updating. Not all commands will have something like this, as some commands may work on a specific range of entities or all entities.</p>
<p>The unit tests for this command are just as basic as those for the <code>CreatePatronCommand</code> class. They are just for making sure that validation can be performed on the object and that it is simple to create a case where it will fail validation.</p>
<pre><code class="language-csharp">using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Vigil.Domain;
using Xunit;

namespace Vigil.MessageQueue.Commands
{
    public class UpdatePatronCommandTest
    {
        [Fact]
        public void Validation_Requires_TargetPatron()
        {
            UpdatePatronCommand command = new UpdatePatronCommand();

            List&#x3C;ValidationResult> validationResults = new List&#x3C;ValidationResult>();
            Validator.TryValidateObject(command, new ValidationContext(command), validationResults, true);

            Assert.Contains(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(UpdatePatronCommand.TargetPatron)));
            Assert.DoesNotContain(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(UpdatePatronCommand.DisplayName)));
            Assert.DoesNotContain(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(UpdatePatronCommand.PatronType)));
            Assert.DoesNotContain(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(UpdatePatronCommand.IsAnonymous)));
        }

        [Fact]
        public void Validation_On_DisplayName_Has_Maximum_String_Length()
        {
            UpdatePatronCommand command = new UpdatePatronCommand()
            {
                TargetPatron = KeyIdentity.NewIdentity(),
                DisplayName = "This is a string with lots of letters appended.".PadRight(1000, 'A'),
                PatronType = "This is a string with lots of letters appended.".PadRight(1000, 'A'),
            };

            List&#x3C;ValidationResult> validationResults = new List&#x3C;ValidationResult>();
            Validator.TryValidateObject(command, new ValidationContext(command), validationResults, true);

            Assert.Contains(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(UpdatePatronCommand.DisplayName)));
            Assert.Contains(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(UpdatePatronCommand.PatronType)));
            Assert.DoesNotContain(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(UpdatePatronCommand.TargetPatron)));
            Assert.DoesNotContain(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(UpdatePatronCommand.IsAnonymous)));
        }
    }
}
</code></pre>
<h2>Factory and Added Tests</h2>
<p>The factory does not need much more than it already has. Adding the <code>UpdatePatron</code> method does show that the validation code between the two methods is the exact same, and so I have refactored that into its own protected method. Otherwise, the only real difference is that the <code>key</code> for the <code>QueueCommand</code> method comes from the <code>UpdatePatronCommand</code> instead of being newly generated.</p>
<pre><code class="language-csharp">using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Vigil.Domain;
using Vigil.MessageQueue;
using Vigil.MessageQueue.Commands;

namespace Vigil.Patrons
{
    public class PatronFactory
    {
        protected readonly ICommandQueue _queue;

        public PatronFactory(ICommandQueue queue)
        {
            _queue = queue;
        }

        public FactoryResult CreatePatron(CreatePatronCommand command)
        {
            List&#x3C;ValidationResult> validationResults = ValidateCommand(command);

            if (validationResults.Any())
            {
                return new FactoryResult(validationResults);
            }
            else
            {
                var key = KeyIdentity.NewIdentity();
                _queue.QueueCommand(command, key);
                return new FactoryResult(key);
            }
        }

        public FactoryResult UpdatePatron(UpdatePatronCommand command)
        {
            List&#x3C;ValidationResult> validationResults = ValidateCommand(command);

            if (validationResults.Any())
            {
                return new FactoryResult(validationResults);
            }
            else
            {
                _queue.QueueCommand(command, command.TargetPatron);
                return new FactoryResult(command.TargetPatron);
            }
        }

        protected List&#x3C;ValidationResult> ValidateCommand(ICommand command)
        {
            List&#x3C;ValidationResult> validationResults = new List&#x3C;ValidationResult>();
            Validator.TryValidateObject(command, new ValidationContext(command), validationResults, true);

            return validationResults;
        }
    }
}
</code></pre>
<p>The added tests are just as easy to write as one would expect. One test to make sure that everything can successfully complete when everything is correct, and one test to make sure that if fails meaningfully.</p>
<pre><code class="language-csharp">using Moq;
using System;
using Vigil.Domain;
using Vigil.MessageQueue;
using Vigil.MessageQueue.Commands;
using Xunit;

namespace Vigil.Patrons
{
    public class PatronFactoryTest
    {
        // PatronFactory.CreatePatron tests omitted.

        [Fact]
        public void User_Can_Update_a_Patron()
        {
            var queue = new Mock&#x3C;ICommandQueue>(MockBehavior.Strict);
            queue.Setup(q => q.QueueCommand(It.IsAny&#x3C;ICommand>(), It.IsAny&#x3C;IKeyIdentity>())).Verifiable();
            PatronFactory factory = new PatronFactory(queue.Object);
            UpdatePatronCommand command = new UpdatePatronCommand()
            {
                TargetPatron = KeyIdentity.NewIdentity(),
                DisplayName = "Updated Patron Name",
                IsAnonymous = null,
                PatronType = null
            };

            FactoryResult result = factory.UpdatePatron(command);

            queue.VerifyAll();
            Assert.Equal(command.TargetPatron.Id, result.AffectedEntity.Id);
            Assert.Empty(result.ValidationResults);
        }

        [Fact]
        public void User_Cannot_Update_Patron_That_Fails_Validation()
        {
            var queue = new Mock&#x3C;ICommandQueue>(MockBehavior.Strict);
            queue.Setup(q => q.QueueCommand(It.IsAny&#x3C;ICommand>(), It.IsAny&#x3C;IKeyIdentity>())).Verifiable();
            PatronFactory factory = new PatronFactory(queue.Object);

            FactoryResult result = factory.UpdatePatron(new UpdatePatronCommand());

            queue.Verify(q => q.QueueCommand(It.IsAny&#x3C;ICommand>(), It.IsAny&#x3C;IKeyIdentity>()), Times.Never);
            Assert.Null(result.AffectedEntity);
            Assert.NotEmpty(result.ValidationResults);
        }
    }
}
</code></pre>
<p>It feels very anti-climactic to be adding so little code just to "Update" an entity, and it is a little overwhelming to thing of all of the code that needs to be written after this to persist the changes, and all of the code that needs to be written before this to allow a real user to generate the command. However, for this small pocket, the work is complete.</p>


User Can Update a Patron

<p>For the fourth year in a row, on Columbus Day weekend, I have completed the Bank of America Chicago Marathon. Previous years have culminated in mixed results, both by the clock and in my own experience. 2013's marathon was a disaster in both time and how I felt during the race, but provided me with invaluable experience and a drive to do better. By the time the 2014 Chicago Marathon came around, I had taken up speed training with <a href="http://coachleach.com/">Coach Leach</a>, focussed a little more on my running form, and put together a strong showing at the 2014 F3 Half Marathon. However, during last year's race, I had set unrealistic expectations, especially while trying to run with a sore back. 2015 was not a good year for me, overall - but I was determined to turn things around for 2016.</p>
<h2>Looking Back at The First Half of 2016</h2>
<p>A lot of dark things happened in my personal life in 2015; but by early 2016, I had started on a recovery course, and I was determined to make 2016 a year of stabilizing my life and pushing forward on my career, my personal life, and my running. The year started with a trip to Disney for the Dopey Challenge. I <a href="/posts/2016/disney-s-dopey-challenge/">wrote about the experience</a> in January, but it's effect on the rest of the year wasn't fully realized until later in the season. By beginning with a rather relaxed race where I couldn't try to set a personal record, it was a refreshing way to get back into running. I wasn't sore for weeks on end, and I didn't have the mental anguish of another missed opportunity.</p>
<p>After having run 48.6 miles over the course of four days, I then had seventeen short days of rest before I ran the F^3 Lake Half Marathon. I have thoroughly enjoyed this race for the last three years. It provides motivation to continue training through the early winter months. When the weather is beautiful (as it was this year), we all enjoy the fabulous day and run fantastic races. When the weather is awful, we all battle through the elements and then enjoy commiserating about how terribly trying it was. Dropping my personal record <a href="https://www.athlinks.com/athletes/193315718?category=1%2F2%20Mara">by nearly five minutes</a> meant I was in high spirits through the rest of Winter Marathon Training.</p>
<p>Having had a <a href="/posts/2015/3-56-58-2015-wisconsin-marathon/">miserable, terrible, never-to-be-repeated experience</a> at the Wisconsin Marathon in 2015, I had elected to go somewhere completely different for 2016. Since my girlfiend was from New Jersey, it seemed like a really good idea at the time (famous last words) to go ahead and sign up for the 2016 Novo Nordisk New Jersey Marathon. The course was splendid for the size of the race, and the running company was good. This was the first time that I tried running with a pace group, and it is an experience which I shall endevour to replicate in future races. My initial goal was to run with the 3:45:00 pace group (would would have still been a six minute PR), but at the very beginning of the race, I decided to throw caution to the wind (a very strong, raining, cross wind at that) and quickly catch up to the 3:30:00 pace group. If I was reading this on someone else's blog, I would expect a tale of misery at going out to fast, and then crashing around mile 16. Inconceivably, at mile 16, I instead pulled away from the pace group and absolutely shattered my personal record, setting a new best time of <a href="https://www.athlinks.com/Athletes/193315718/Race/256045904">3:24:31</a>.</p>
<h2>#Whole30 Nutrition Program &#x26; A Personal Trainer</h2>
<p>As the summer rolled in, my girlfiend and I decided to do the #Whole30 challenge. In support of her, I did not alter any of my meals or nutrition to cheat the program. Some other endurance athletes, I had read, would mostly do the challenge, but still use their sugar-filled gels during the run. I was determined to be fully compliant throughout the 30 days, including on long runs. The first thing that I noticed was the change in energy output during my weekend runs. Previously, I would experience a high energy for many miles, but I could feel this slowly fade away as the miles grew longer. However, on the #Whole30 plan, I felt I had a high level of energy through many more miles than before - but with a significant and sudden drop after some point. After a bit of trial and error, I was able to add more calories throughout the week, which I found boosted the number of miles I could sustain until exhaustion. I have so much to say about this topic that I should probably just write another post dedicated to this.</p>
<p>Another notable change in habit was working out with a personal trainer two days a week. While this meant reducing the number of days a week I was running, I found that my running economy was greatly improved and my recovery periods were markedly decreased. Between the two changes, I had shed approximately 20 pounds of excess body weight. I also spent a small fortune on new clothes to drape the slimmed down frame.</p>
<p>I could probably go on about this for another three paragraphs, but I'll save that for another post. All of this work over the summer led to a smashing success at the annual Universal Sole Burgers &#x26; Beer 5k race, <a href="http://onlineraceresults.com/race/view_plain_text.php?race_id=54184">completing in 19:21.6</a>; placing 20th overall and 6th in the very competitive M30-34 division. I was estatic with my performance, and it reinvigorated my dedication to training for the Chicago Marathon.</p>
<h2>A New Training Regiment</h2>
<p>With the addition of working out in the gym two days a week, I changed up my running schedule. My week thus looked like this:</p>
<ul>
<li>Monday: Run to work (minimum 9 miles, peaked at 12 miles) between marathon and threshold pace.</li>
<li>Tuesday: Work out with Personal Trainer</li>
<li>Wednesday: Run to work (minimum 9 miles, peaked at 15 miles) between easy and marathon pace.</li>
<li>Thursday: Work out with Personal Trainer</li>
<li>Friday: rest</li>
<li>Saturday: Long run with CARA (between 8 and 22 miles) at easy pace</li>
<li>Sunday: rest</li>
</ul>
<p>I must say that I thoroughly enjoyed this set-up. I never felt the tedium of running that I had felt in previous years. I never felt overly stained or worrying about injury. The whole summer passed without serious incident, and the end of September approached rather quickly.</p>
<h2>End of September</h2>
<p>Then I got married and we went to Paris and London for the honeymoon.</p>
<h2>Chicago Marathon 2016</h2>
<p>The day was finally here, and I felt woefully underprepared. Normally, I would have had everything all packed up the night before, but I was scrambling around and lost when I wanted to be heading to bed. So I just figured I would work it all out in the morning; and so I crashed. I slept horribly. Even when I finally decided to get out of bed, I just couldn't piece together a satisfactory list of what I wanted to bring to race day. It turns out that I had absolutely everything I would normally bring, but I had a nagging feeling the entire L ride downtown that I had forgotten something. On top of that, there was a really annoying passenger that kept wanting to engage me in conversation when I really just wanted to pop in my headphones and listen to some calming piano pieces. Eventually, I arrived at the CARA compound and the familiarity started to fall into place. I started going through the pre-race motions of replacing compression socks and walking shoes with running socks and race shoes; attaching my bib to the shirt I was going to wear; bundling up in an old long-sleeves shirt and worn gloves; and triple checking watch, cellphone, nutrition. There is a lot to be said about routine to clear one's head. I left the compound an hour before race time, and casually walked to my corral. Last year (when the compound was farther), this barely got me into my corral before they closed the gates. This time around, I was easily at the front of Corral C, and found myself in a more relaxed mood because of it. The temperature was cool with only a slight breeze.</p>
<p>Corral C's fastest pace group was a 03:25:00. Having already run faster than that, I had my eye on catching up to the 03:20:00 pace group in Corral B. Once released onto the course, I set myself at a measured pace, and felt good on my quest to catch up with my rabbits. I found them at around mile four but I couldn't get myself to easily pull back to their pace, and I soon found myself creeping ahead of them. I carried on at the pace I was holding, and started doing the math in my head for whether I might catch the 03:15:00 pace group and when I would overrun them. Before the half way point in the race, I had found and passed that pace group. Twice I was able to see my wife, mom, son, and some friends - all estatic to see me. I knew I was going too fast, and when I had a midway split of 01:33:11, I had no doubt that I was going to crash and burn before the end of the marathon. My only goal at this point was to hold out for as long as I could, and see how close I could come to the finish line before it all fell apart.</p>
<p>The 30k mark was about as far as I could get at the pace I was running, and then I had to painfully slow down, which turned into a bit of a run-walk. A few miles later, the 03:15:00 pace group passed me, and then close to the end, the 03:20:00 pace group trotted passed me. I knew they were coming for me, so it didn't completely demoralize me, but there was a sense of loss at knowing what finish time I was losing. Starting with the aid station in mile 20, I was able to get myself to run to the banana tables, eat nearly a full banana, get some water, then proceed with my race. I would walk through the aid station, then start running slowly, then picking up to an acceptable pace. At mile 23.5, I had the first cramp I've ever had during a run; thankfully, I was able to walk it off before the block ended. Michigan Avenue was, once again, a torturously long 2.5 miles. I kept with the Fartlek-like intervals, and the pavement eventually moved along — my eye ever on the clock. I knew I could still set a personal record, as long as I kept moving. Walk a little, slow run a little, easy pace as long as possible; rinse and repeat.</p>
<p>At the 800m mark, I was going to walk another interval, but a friend of mine jump the barricade, ran across Michigan Ave, waved her arms like a crazy person. I looked over to where she came from and found my entourage excitedly cheering for me. It was an unexpected and wonderful surprise, and I couldn't let them see me walk - so on I went! I was able to take that surge of energy, climb over Mount Roosevelt, and run across the finish line.</p>
<h2>Official Results - <a href="http://results.chicagomarathon.com/2016/?content=detail&#x26;idp=999999107FA309000019E6EC">03:21:43</a></h2>
<p>My time for the first half of the marathon was the fastest that I've run 13.1 miles before. It is also the pace that I will need to run to be able to qualify and race in Boston. 03:06:22 would be a very solid time to be able to submit, and would further grant me guaranteed entry into the next years' Chicago Marathon (03:15:00 being the cut off). I feel good having the experience of what that pace will feel like, and how I can best manage the race. Assuming I can move up a corral for next year's Chicago Marathon, I will attempt to attach myself to the 03:05:00 pace group and stick with them the whole race.</p>
<p>The other thing that I learned is that two LaraBars are not nearly enough nutrition to get me through the race. I would have liked at least four, and I could have also used either salt tablets or <a href="http://www.seattletimes.com/seattle-news/health/pickle-juice-yellow-mustard-for-muscle-cramps/">mustard packets</a>. I think the added nutrition would have helped with the energy crash and the cramping may have been from my sodium dropping too low. These are both things that I will try during my next marathon, and if it works out, will definitely be in store for all further races.</p>
<h2>And On a Lighter Note</h2>
<p><a href="https://www.dnainfo.com/chicago/20161009/downtown/chicago-marathon-dogs"><img src="/images/2016chi-cute-puppy.jpg" alt="Adorable Pups Were The Cutest Spectators At The 2016 Chicago Marathon"></a></p>


2016 Chicago Marathon Wrap-up

<p>For a while, I have been battling with where validation should occur, and who is responsible for ensuring that the information in a command is good data. For the first layer of data validation, I am turning to the Command to validate itself — the mere application of data types is a rudimentary form of data validation, so including addition simple validation extends that basic logic.</p>
<h2>Simple Validation</h2>
<p>Taking a queue from the <a href="https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations.ivalidatableobject.aspx"><code>IValidatableObject</code></a> interface, simple validation logic will be handled by the command itself. I am defining <em>simple</em> as validation that requires no external knowledge.</p>
<pre><code class="language-csharp">using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using Vigil.Domain;

namespace Vigil.MessageQueue.Commands
{
    public class CreatePatronCommand : ICommand
    {
        [Required, StringLength(250)]
        public string DisplayName { get; set; }
        [DefaultValue(false)]
        public bool IsAnonymous { get; set; } = false;
        [Required, StringLength(250)]
        public string PatronType { get; set; }
    }
}
</code></pre>
<p>This validates that both the <code>DisplayName</code> and the <code>PatronType</code> are not longer than 250 characters and are not empty. There is no validation as to whether the <code>PatronType</code> exists in some look-up table, or whether the <code>DisplayName</code> is unique (or if it even needs to be unique).</p>
<h2>Why A Command Does Not Require Itself Be Valid</h2>
<p>Even though the Command knows <em>how</em> to validate itself, I have decided that the command is not required to actually ensure that it is valid before work is performed on it — for two reasons. First, a Command is merely a carrier for information, and only understands simple rules governing whether the data is in a valid state. There are many cases where it is acceptable for a Command to be in an invalid state — when logging failed attempts, or when saving an in progress state. Second, a Command does not actually know when work is being performed on its information. Other objects (the message queue, the command handler, the command logger) are responsible for deciding if the data needs to be fully valid and then whether the data actually is valid. This was a bit of a struggle for me early on, because if the object knows <em>how</em> to validate itself, shouldn't it also make sure that it is always in a valid state? It was when I started thinking about persisting partial states and persisting failed states that I began to realize how to solve this conundrum.</p>
<h2>Who Validates the Validation?</h2>
<p>In my current system design, I am relying on the Factory to handle validating that a Command's data has passed all of its internal data integrity checks. As I've already mentioned the <code>IValidatableObject</code>, it should come as no surprise that I intend to use the <code>DataAnnotations</code> namespace to perform the validation.</p>
<pre><code class="language-csharp">using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Vigil.Domain;
using Vigil.MessageQueue;
using Vigil.MessageQueue.Commands;

namespace Vigil.Patrons
{
    public class PatronFactory
    {
        protected readonly ICommandQueue _queue;

        public PatronFactory(ICommandQueue queue)
        {
            _queue = queue;
        }

        public FactoryResult CreatePatron(CreatePatronCommand command)
        {
            List&#x3C;ValidationResult> validationResults = new List&#x3C;ValidationResult>();
            Validator.TryValidateObject(command, new ValidationContext(command), validationResults, true);

            if (validationResults.Any())
            {
                return new FactoryResult(validationResults);
            }
            else
            {
                var key = KeyIdentity.NewIdentity();
                _queue.QueueCommand(command, key);
                return new FactoryResult(key);
            }
        }
    }
}
</code></pre>
<p>There are some odd quirks that I will have to remember, the primary (at this point) being the order that validation occurs, and when it aborts further validation. Jeff Handley goes into more detail in his post <a href="http://jeffhandley.com/archive/2009/10/16/validator.aspx">Validating Objects and Properties with Validator</a>, but the key piece that I took away from it that I hadn't figured out while playing with the API is this:</p>
<blockquote>
<ol>
<li>Validate property-level attributes</li>
<li>If any validators are invalid, abort validation returning the failure(s)</li>
<li>Validate the object-level attributes</li>
<li>If any validators are invalid, abort validation returning the failure(s)</li>
<li>Call its Validate method and return any failure(s)</li>
</ol>
</blockquote>
<h2>Complex Validation</h2>
<p>I have not yet solved the problem of how to validate a command that requires external knowledge. At some point, I am going to need to be sure that a command has valid information with regards to all other information in a system. Account numbers must be unique and sequential; transaction dates must be the same as the date of the batch; schedule effective date ranges cannot overlap. Whatever does the validation will have to have knowledge of the state of other common data points - maybe it doesn't specifically know what the persistence technology is, but the validating object will need to know how to compare the Command's data with persisted data. Who gets this priviledge? I have not yet figured that one out.</p>


A Word On Validation

<p>Creating a patron (by which I mean, issuing a command such that some process somewhere will instantiate an actual Patron entity, and perhaps persist it in some useful manor) is all well and good, until someone tries to stuff in data that isn't valid. Users like to do things like this all the time, so I am going to attempt to protect against it from the beginning. Additionally, by setting up the mechanisms to test validation and perform validation, I should be able to keep a culture of enforcing these conventions throughout development.</p>
<h2>*"Cannot"</h2>
<p>With everything revolving around commands, telling a user something can't be done is less accurate, and it is more about declining to queue the command and letting the user know why. This starts by actually validating the command in question.</p>
<pre><code class="language-csharp">using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Vigil.Domain;
using Vigil.MessageQueue;
using Vigil.MessageQueue.Commands;

namespace Vigil.Patrons
{
    public class PatronFactory
    {
        protected readonly ICommandQueue _queue;

        public PatronFactory(ICommandQueue queue)
        {
            _queue = queue;
        }

        public FactoryResult CreatePatron(CreatePatronCommand command)
        {
            List&#x3C;ValidationResult> validationResults = new List&#x3C;ValidationResult>();
            Validator.TryValidateObject(command, new ValidationContext(command), validationResults, true);

            if (validationResults.Any())
            {
                return new FactoryResult(validationResults);
            }
            else
            {
                var key = KeyIdentity.NewIdentity();
                _queue.QueueCommand(command, key);
                return new FactoryResult(key);
            }
        }
    }
}
</code></pre>
<h2>**"Validation"</h2>
<p>Who actually performs the validation is questionable. For now, I have decided to place the onus on the command to know what makes it valid. As a first step, I am just using the <code>DataAnnotations</code> attributes, as they serve my needs for now. In the future, I know that I will need to do look-up validation (is the <code>PatronType</code> valid), but for now I am just demonstrating that the bare minimum works.</p>
<pre><code class="language-csharp">using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using Vigil.Domain;

namespace Vigil.MessageQueue.Commands
{
    public class CreatePatronCommand : ICommand
    {
        [Required, StringLength(250)]
        public string DisplayName { get; set; }
        [DefaultValue(false)]
        public bool IsAnonymous { get; set; } = false;
        [Required, StringLength(250)]
        public string PatronType { get; set; }
    }
}
</code></pre>
<h2>Testing the Code</h2>
<pre><code>CreatePatronCommandTest:
  ✅ Validation_On_DisplayName_Has_Maximum_String_Length
  ✅ Validation_Requires_DisplayName_and_PatronType

PatronFactoryText
  ✅ User_Can_Create_New_Patron
  ✅ User_Cannot_Create_Patron_That_Fails_Validation
</code></pre>
<p>Of course, since new code has been added, new tests need to be made. Following the Microsoft convention for where tests are located, the solution is broken into two root folders: src and test. There is a one-to-one matching of projects with real code in the src folder, and projects that hold the unit tests for those projects. Test projects have the same name as their target, suffixed with '.Tests' (eg. <code>src\Vigil.Domain</code> and <code>test\Vigil.Domain.Tests</code>). The folder structure in the two projects should be identical, and all test classes have the same name as their target class, suffixed with 'Test' (eg. <code>Vigil.Patrons.PatronFactory</code>, <code>Vigil.Patrons.PatronFactoryTest</code>).</p>
<pre><code class="language-csharp">using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Xunit;

namespace Vigil.MessageQueue.Commands
{
    public class CreatePatronCommandTest
    {
        public void CreatePatronCommand_Defaults_IsAnonymous()
        {
            CreatePatronCommand command = new CreatePatronCommand();

            Assert.False(command.IsAnonymous, "Default Value of CreatePatronCommand.IsAnonymous changed from 'false'.");
            Assert.Null(command.DisplayName);
            Assert.Null(command.PatronType);
        }

        [Fact]
        public void Validation_Requires_DisplayName_and_PatronType()
        {
            CreatePatronCommand command = new CreatePatronCommand();

            List&#x3C;ValidationResult> validationResults = new List&#x3C;ValidationResult>();
            Validator.TryValidateObject(command, new ValidationContext(command), validationResults, true);

            Assert.Contains(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(CreatePatronCommand.DisplayName)));
            Assert.Contains(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(CreatePatronCommand.PatronType)));
            Assert.DoesNotContain(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(CreatePatronCommand.IsAnonymous)));
        }

        [Fact]
        public void Validation_On_DisplayName_Has_Maximum_String_Length()
        {
            CreatePatronCommand command = new CreatePatronCommand()
            {
                DisplayName = "This is a string with lots of letters appended.".PadRight(1000, 'A'),
                PatronType = "Invalid Type"
            };

            List&#x3C;ValidationResult> validationResults = new List&#x3C;ValidationResult>();
            Validator.TryValidateObject(command, new ValidationContext(command), validationResults, true);

            Assert.Contains(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(CreatePatronCommand.DisplayName)));
            Assert.DoesNotContain(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(CreatePatronCommand.PatronType)));
            Assert.DoesNotContain(validationResults, vr => vr.MemberNames.Any(mn => mn == nameof(CreatePatronCommand.IsAnonymous)));
        }
    }
}
</code></pre>
<pre><code class="language-csharp">using Moq;
using System;
using Vigil.Domain;
using Vigil.MessageQueue;
using Vigil.MessageQueue.Commands;
using Xunit;

namespace Vigil.Patrons
{
    public class PatronFactoryTest
    {
        [Fact]
        public void User_Can_Create_New_Patron()
        {
            var queue = new Mock&#x3C;ICommandQueue>(MockBehavior.Strict);
            queue.Setup(q => q.QueueCommand(It.IsAny&#x3C;ICommand>(), It.IsAny&#x3C;IKeyIdentity>())).Verifiable();
            PatronFactory factory = new PatronFactory(queue.Object);

            FactoryResult result = factory.CreatePatron(new CreatePatronCommand()
            {
                DisplayName = "Test User",
                IsAnonymous = false,
                PatronType = "Test Account"
            });

            queue.VerifyAll();
            Assert.NotEqual(Guid.Empty, result.AffectedEntity.Id);
            Assert.Empty(result.ValidationResults);
        }

        [Fact]
        public void User_Cannot_Create_Patron_That_Fails_Validation()
        {
            var queue = new Mock&#x3C;ICommandQueue>(MockBehavior.Strict);
            queue.Setup(q => q.QueueCommand(It.IsAny&#x3C;ICommand>(), It.IsAny&#x3C;IKeyIdentity>())).Verifiable();
            PatronFactory factory = new PatronFactory(queue.Object);

            FactoryResult result = factory.CreatePatron(new CreatePatronCommand());

            queue.Verify(q => q.QueueCommand(It.IsAny&#x3C;ICommand>(), It.IsAny&#x3C;IKeyIdentity>()), Times.Never);
            Assert.Null(result.AffectedEntity);
            Assert.NotEmpty(result.ValidationResults);
        }
    }
}
</code></pre>


User Cannot* Create Patron That Fails Validation**

<p>For simplicity, the <code>PatronFactory</code>'s <code>CreatePatron</code> method just returned an <code>IKeyIdentity</code>. This was a simple interface that requires an <code>Id</code> of type <code>Guid</code>. When the creation method was always assumed to work correctly, this was fine - I don't have to worry about validation checking, data errors, or anything that might cause a failure. However, in the real world, I need to be aware of these things. As such, the first refactor that I'm going to perform is to change the return type to a multi-purpose class.</p>
<h3>FactoryResult</h3>
<pre><code class="language-csharp">using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace Vigil.Domain
{
    public class FactoryResult
    {
        public ICollection&#x3C;ValidationResult> ValidationResults { get; protected set; }
        public IKeyIdentity AffectedEntity { get; protected set; }

        public FactoryResult(ICollection&#x3C;ValidationResult> validationResults)
        {
            ValidationResults = validationResults;
        }
        public FactoryResult(IKeyIdentity affectedEntity)
        {
            AffectedEntity = affectedEntity;
        }
    }
}
</code></pre>
<p>The <code>PatronFactory</code> will now return this class. If there were problems, then the <code>ValidationResults</code> collection will contain elements; if all went well, then <code>IKeyIdentity</code> should not be null. Tests were updated to reflect this, and now I am ready to add validation (<a href="/posts/2016/user-cannot-create-patron-that-fails-validation/">next post</a>).</p>
<h3>A Quick Note About Contracts</h3>
<p>Currently, Code Contracts is not supported for .NetCore and is not coming to C# 7.0, which makes me very sad - it is also the number one requested feature for <a href="https://visualstudio.uservoice.com/forums/121579-visual-studio-2015/suggestions/2320188-add-non-nullable-reference-types-in-c">C# on the Visual Studio uservoice</a>. While the primary use of Design by Contract was for eliminating null references, there were still plenty of other places it was extremely useful. Especially with <code>Guid</code>s becoming the primary source of identifiers, it was very helpful to be able to Require that a Guid could not be Empty, or that a value was in a given range.</p>
<p>So, it is with a sad heart that I have removed Contracts from this project entirely. I will start putting in null reference checks where appropriate, but for the most part, I will do what I can to find an alternative solution.</p>


A Word On Factory Results and Contracts

<p>The first thing that I learned with Dependency Injection is that it encourages a mindset of "I'll figure that out that later." This allows me to put in the bare minimum for what might pass a test, even though I know it will have all kinds of complex integration somewhere down the line. To start this little experiment, I am going to put together a tiny amount of arguably functional code. I will start with the very simple definition of what a User is, what it means to Create an entity, and how a Patron is represented.</p>
<h2>*"User"</h2>
<p>A "User" in this case is the arbitrary creator of a command and consumer of the factory. For now, the User is the test suite (powered by xUnit).</p>
<pre><code class="language-csharp">using Moq;
using System;
using Vigil.Domain;
using Vigil.MessageQueue;
using Vigil.MessageQueue.Commands;
using Xunit;

namespace Vigil.Patrons
{
    public class PatronFactoryTest
    {
        [Fact]
        public void User_Can_Create_New_Patron()
        {
            var queue = new Mock&#x3C;ICommandQueue>(MockBehavior.Strict);
            queue.Setup(q => q.QueueCommand(It.IsAny&#x3C;ICommand>(), It.IsAny&#x3C;IKeyIdentity>())).Verifiable();
            PatronFactory factory = new PatronFactory(queue.Object);

            IKeyIdentity result = factory.CreatePatron(new CreatePatronCommand()
            {
                DisplayName = "Test User",
                IsAnonymous = false,
                PatronType = "Test Account"
            });

            queue.VerifyAll();
            Assert.NotEqual(Guid.Empty, result.Id);
        }
    }
}
</code></pre>
<h2>**"Create"</h2>
<p>At this point, I am going to define Create as issuing the command to <em>something else</em> to instantiate and persist a new representation of the entity.</p>
<pre><code class="language-csharp">using System.Diagnostics.Contracts;
using Vigil.Domain;
using Vigil.MessageQueue;
using Vigil.MessageQueue.Commands;

namespace Vigil.Patrons
{
    public class PatronFactory
    {
        protected readonly ICommandQueue _queue;

        public PatronFactory(ICommandQueue queue)
        {
            _queue = queue;
        }

        public IKeyIdentity CreatePatron(CreatePatronCommand command)
        {
            Contract.Requires(command != null);
            Contract.Ensures(Contract.Result&#x3C;IKeyIdentity>() != null);

            var key = KeyIdentity.NewIdentity();

            _queue.QueueCommand(command, key);

            return key;
        }
    }
}
</code></pre>
<h2>***"Patron"</h2>
<p>A patron, this early in development, is an abstract representation of what should be created - it does not care about persistence or structure.</p>
<pre><code class="language-csharp">using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using Vigil.Domain;

namespace Vigil.MessageQueue.Commands
{
    public class CreatePatronCommand : ICommand
    {
        [Required, StringLength(250)]
        public string DisplayName { get; set; }
        [DefaultValue(false)]
        public bool IsAnonymous { get; set; } = false;
        [Required, StringLength(250)]
        public string PatronType { get; set; }
    }
}
</code></pre>
<h2>ICommandQueue Interface</h2>
<p>The most basic, simple interface with the bare minimum for what a message queue would need to implement.</p>
<pre><code class="language-csharp">using Vigil.Domain;

namespace Vigil.MessageQueue
{
    public interface ICommandQueue
    {
        void QueueCommand(ICommand command, IKeyIdentity key);
    }
}
</code></pre>
<h2>ICommand Interface</h2>
<p>This is just a simple way to identify commands and provide a way for future restrictions and contracts, when I need them.</p>
<pre><code class="language-csharp">namespace Vigil.Domain
{
    public interface ICommand
    {
    }
}
</code></pre>


User* Can Create** New Patron***

<p>There can be a lot of issues with figuring out how to identify an object, especially as I try to track it across various services, platforms, persistance strategies, and even entire systems. For a while, I played around with just having every object contain its own identification field. However, it was painful having to remember to put the same and correct field(s) on every entity. I stumbled upon a blog post (which I cannot find anymore), which talked about pulling the key out into its own class, and have everything inherit from there. I'm not entirely sure I like the idea of a super-base-class, but I think it at least gives me a good place to isolate the key into a globally consistent way.</p>
<h2>Globally Unique Identifier</h2>
<p>Having the identifier at the time of initialization turned out to save all kinds of problems for me. When persisting to a database, I no longer have to wait to select the inserted record to find its identity. I can pass entities between services, pass the key to another service, or check on queues by that Guid.</p>
<h2>IKeyIdentity Interface</h2>
<p>By abstracting the key to an interface, I can decide later if and how I would like to change it. This will limit the places that are impacted if I need to change out the type of the Id, or add more fields. Also, by having methods use an interface instead of a concrete class, it becomes much easier to mock this when testing. Faking an interface is much easier than building entire test classes.</p>
<pre><code class="language-csharp">using System;

namespace Vigil.Domain
{
    public interface IKeyIdentity
    {
        Guid Id { get; }
    }
}
</code></pre>
<h2>KeyIdentity Interface</h2>
<p>This is the basic implementation of the <code>IKeyIdentity</code> interface. It follows the <code>ValueObject</code> convention, making the <code>Guid</code> immutable, but also adds the ability to compare any two objects by their <code>Guid</code>.</p>
<pre><code class="language-csharp">using System;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.Contracts;

namespace Vigil.Domain
{
    public class KeyIdentity : IEquatable&#x3C;KeyIdentity>, IKeyIdentity
    {
        public static KeyIdentity NewIdentity()
        {
            return new KeyIdentity();
        }

        [Key]
        public Guid Id { get; protected set; }

        protected KeyIdentity()
        {
            Id = Guid.NewGuid();
        }

        protected KeyIdentity(Guid id)
        {
            Id = id;
        }

        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj))
            {
                return false;
            }
            if (ReferenceEquals(this, obj))
            {
                return true;
            }
            if (obj.GetType() != GetType())
            {
                return false;
            }
            return Equals((KeyIdentity)obj);
        }

        public bool Equals(KeyIdentity other)
        {
            if (other == null)
            {
                return false;
            }
            return Equals(other.Id, Id);
        }

        public static bool operator ==(KeyIdentity left, KeyIdentity right)
        {
            return Equals(left, right);
        }
        public static bool operator !=(KeyIdentity left, KeyIdentity right)
        {
            return !Equals(left, right);
        }

        public override int GetHashCode()
        {
            return Id.GetHashCode();
        }

        public override string ToString()
        {
            return Id.ToString();
        }

        [ContractInvariantMethod]
        private void ObjectInvariant()
        {
            Contract.Invariant(Id != Guid.Empty);
        }
    }
}
</code></pre>


Rovani's Sandbox

Blog Posts - Page 10

User Can Update a Patron

2016 Chicago Marathon Wrap-up

A Word On Validation

User Cannot* Create Patron That Fails Validation**

A Word On Factory Results and Contracts

User* Can Create New Patron*

Everything Gets an Id