<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>


Everything Gets an Id

<p>As I have been working on the Vigil project, I have been accidentally stumbling onto various patterns. I will go in search of a way to solve some particular problem, and end up losing several hours while I research some reference the author made about a concept (or, usually, an acronym) at the end of a post as some kind of <em>a posteriori</em>. The two largest design patterns that I am most excited about are Command Query Responsibility Segregation (CQRS) and Event Sourcing (ES).</p>
<h2>Accidentally Implementing CQRS</h2>
<p>I found that I wasn't enjoying how all of my database logic was being tied up first inside of my Controller. I refactored, pulling all of the database logic out and putting it into its own class (someone had used the word <em>Repository</em> somewhere, so I called it that). I have always liked pulling code out of the Web Application project and putting it into its own project - so this new Repository got moved there. However, it meant that the View Models that I was using in the Controller could no longer be access by the Repository. Thus, the View Models got moved to the (what is now called) Domain project. But wait - now I have to modify a class in the Domain project if I want to change some data passed to the View. This didn't look right, so the View Models went back into the Web Project and a new set of classes were made - I called these Models. Ok, but now I need a way to turn the View Models into Models - or more accurately, extract the data from one and reconstruct it in the other. For this, I invented Mappers, which just handled shuttling data between my (what I found out were called) POCO classes. It turns out that Mappers can roughly be translated into Command Handlers, if I think of the Factory as a bus, and the POCO as my Command.</p>
<p>Thus, my commands and queries are separated out. Queries are happening in the Repositories, and Commands are happening in the Factories. Event Sourcing is also half way to being implemented, because my commands get pushed up to and object that then handles what to do with them. This means all I am really missing is separating the validation of a command from the actual execution of the command, and I still need to add Event Sourcing.</p>
<h2>Where Am I Going With This?</h2>
<p>There are lots of examples of implementing little pieces of CQRS and ES here and there, spread throughout the web. What I could not find was a single series of posts about taking a completely greenfield project and building up each component of the code, including unit testing. From there, it would be a set of posts about integration and doing integration testing. I think that is where I want to take the Vigil Project. I will keep a branch with "snapshots" of where the code is at each blog post, and I can provide a post detailing each piece of the project. This will include my thoughts for each direction I took, places where I changed my mind (either voluntarily or by force), and the actual code that was generated.</p>
<p>We'll see how this goes. Any ideas on a rough template for what this series might look like? Let me know below.</p>


Stumbling Into Design Patterns

<p>I am working on migrating my blog from the old hosted Wordpress site that I was using to be hosted by GitHub pages, powered by Jekyll.</p>
<p>Why, you might ask. Because I can.</p>
<p>Also, because I want to use my domain to host this, and I <em>think</em> that I can do that with Google Domains and this site. We'll see how that works out.</p>
<h2>Progress</h2>
<ul>
<li>2016-08-11: I migrated from the beginning through 02 April 2014. It's a good start, I think.</li>
<li>2016-08-12: I've migrated through 23 Jan 2015. Slowly but surely!</li>
<li>2016-08-17: Since I had to fix the encoding on all of the markdown files, I spent most of the day fixing all of the question marks.</li>
<li>2016-08-24: I migrated everything from the Wordpress blog, and some of the more important posts from Exactly One Hobby.</li>
</ul>


Hello World!

<p>The <em>Dopy Challenge</em> is a four day event at Walt Disney World Resorts.</p>
<ol>
<li>Thursday - Pluto's 5k</li>
<li>Friday - Minnie's 10k</li>
<li>Saturday - Donald Duck's Half Marathon</li>
<li>Sunday - Mickey Mouse's Marathon</li>
</ol>
<p>In completing the Half Marathon and full Marathon, <em>Dopey Challenge</em> participants also satisfy the requirements for the <em>Goofy's Race and a Half Challenge</em>. This results in six medals, six t-shirts, and four extremely early mornings. I had a lot of fun doing the events, but once is certainly enough for me. It was a unique tour of the parks, getting to run through two for the half marathon and all four for the full marathon; however, circling Epcot two additional times for the 5k and 10k made the final return trip at the end of the marathon torturous. Getting up at 3:45 for four mornings in a row put a huge damper on enjoying the rest of the trip. Combine that with the overall cost, and I cannot see myself doing the challenge again; however, I would consider doing the <em>Goofy Challenge</em>, again.</p>
<h2>My Experience and Lessons Learned</h2>
<p>If you are reading this post, you probably already know enough about the challenge that I don't need to spell out all the details. The <a href="http://www.rundisney.com/disneyworld-marathon/#dopey-challenge">runDisney website</a> does a sufficient job describing the event beyond what I wrote above. I ran the Half Marathon with my girlfriend, but did the other three races by myself. There are a couple of key lessons that I definitely learned (the hard way) that would have greatly improved my experience.</p>
<h3>Submit your Proof of Time Qualifying Results</h3>
<p>This is something that I missed when I registered. For the Chicago Marathon, the organizers send out multiple emails reminding runners to log into the website and add their Proof of Time. Since I didn't do this, I was stuck at the back for all four races. It was <em>awful</em>. As someone who can casually run a 24 minute 5k, I was stuck behind all of the walkers — all of which seemed perfectly happy walking six wide through the narrow parts of the course. The 10k was just as bad. The half marathon was as bad, but I noticed it less, since I was running with at my girlfriend's pace, and she was perfectly content slowing to a walk during the bottlenecks. For the marathon, it was absurd how often I was running through and around large groups with zero course etiquette.</p>
<p>If you are in a later corral for any of the races, expect to be standing around for a very long time. It was at least 41 minutes between the race start and when I was on course for the 5k, 49 minutes for the 10k. For the half and full marathon races, it was over an hour. If you are staying at Disney, take the latest possible bus you can, and take your sweet ass time getting to the corral. It is close to negligent how long it takes to get everyone onto the course. Additionally, expect significant delays throughout the race. The course narrows to just a single lane on a narrow access road throughout many different parts of the course. I understand the need, from an operations standpoint, for this (their employees still need to get to work); but the bottleneck brings athletes to a complete standstill.</p>
<h3>This Isn't a Race, It's a Guided Tour Of Disney</h3>
<p>It wasn't until I was halfway through the Half Marathon that I had the realization that these aren't races, like every other running event I had done. Instead, this was a paid, self-guided tour through the various parks at Disney World. There are no awards for overall place or age bracket places; few people are attempting to qualify for Boston. The entertainment along the course is, in fact, designed to delay you - who can pass up a picture with your favorite Disney characters? The challenge is also a great way to pad the number of participants for the 5k and 10k, and to convince runners to stay at the parks a few extra days. Especially with the expo being on Wednesday, you have to be there for at least four five nights - because who is going to go home Sunday night.</p>
<h3>You Will Get Sick Of Seeing That Damn Golfball</h3>
<p>Since all four races start and end in the Epcot parking lot, you will have to run through the front, and around back of <em>Spaceship Earth</em> four different times. Come the end of the marathon, you are going to loathe seeing that geodesic horror once more. After I finished the marathon, I had the choice of which park we were going to visit, and while I would have liked to walk around Epcot, I hated the idea of seeing it yet again that I chose to go to <em>Animal Kingdom</em> instead (had a wonderful time there, too).</p>
<h3>Extend Your Trip An Extra Day</h3>
<p>A friend who works for Disney said that the second weekend in January used to be the slowest weekend at the parks, which is why that weekend is now Marathon Weekend. It is now also one of their business non-holiday weekends. However, I can attest from experience that nearly everyone goes home on the Monday after the marathon. The park and the resort we lodged at were both nearly empty. Park lines were almost nonexistent and there were no crowds at restaurants during peak meal times. If you can afford to stay an extra day, definitely plan on spending Monday doing all of the things that you would normally have to wait in long lines.</p>
<h3>Enjoy The weekend</h3>
<p>In spite of all of these early mornings, terribly long corrals, mediocre race support, and exhaustive expense — it certainly was a fun weekend, made all the better by the company and the visits to the parks. I am glad to have done it, but more at being able to say that I've done it. In the future, there are certainly bigger challenges that await the ambitious feats of endurance I might undertake (Ragnar, RAGBRAI, Ironman, etc).</p>


Disney's Dopey Challenge

<p>I've finally done it; I finally ripped, twisted, and otherwise cajoled the default MVC template, Identity code, and a few other tweaks I wanted to make into something I am semi-confident will be a good starting point for future projects. Which is really to say ? I'm at a stopping point and I'll probably burn it all to the ground, tomorrow.</p>
<h2>The Best Things In Life Are Passed Tests</h2>
<p>Sometimes, the best thing that can happen in my day is that all of the unit tests pass. Not just once, due to some odd coincidence with timing, but because they actually, legitimately pass. I am sure that veterans of Test Driven Development will scoff at a lot of these tests. However, it was fun to learn how to use <a href="https://xunit.github.io/">xUnit</a> and <a href="http://www.moqthis.com/">Moq</a>. Previously, I had been determined that I was going to be able to write my tests without using external libraries. I was just going to extend the different classes that depend on external resources and change them all to work in memory. This was stupid, time consuming, and generally fraught with errors. My tipping point was when I realized I was writing tests for these Test classes.</p>
<p>How awful is that?</p>
<p>I chose xUnit and Moq because they seemed to be the most popular. The primary difficulty that I have with mocking at this point are extension methods. Since I cannot mock a non-virtual member, mocking the extension classes is impossible. Thus, I need to find the source code, figure out exactly what the extension method is doing, and properly mock whatever method is used internally. It was a frustrating set of investigations, but I did enjoy digging into the internals of Identity and <a href="https://katanaproject.codeplex.com/">Katana</a>.</p>
<h2>Tests that Cover Code</h2>
<p>It feels like half of my tests are in place just to improve my Code Coverage percentages. Even with that, there are two sticking points that I am having trouble getting over. The first are some the set portion of automatic properties in my <a href="https://github.com/drovani/Vigil/blob/VigilBaseSolution/Vigil.Data/Vigil.Data.Core/Identity.cs">Identity</a> and <a href="https://github.com/drovani/Vigil/blob/VigilBaseSolution/Vigil.Data/Vigil.Data.Core/TypeBase.cs">TypeBase</a> abstract classes. I have searched high and low and cannot find a solution to this. I am hoping that as I inherit from these classes, tests on those new classes will happen to start covering these properties.</p>
<p>The second part is managing to get the MoveNext() method to register as covered. It's a pain to get <a href="http://blogs.msdn.com/b/dwayneneed/archive/2014/11/17/code-coverage-with-async-await.aspx">Code Coverage with Async Await</a>, but Dwayne Need's blog post was very informative. It will be a while before I worry about getting that in depth with the code coverage that I will need to put all this work together for what amounts to no (seemingly) real gain.</p>
<p>Another "close enough" for Code Analysis</p>
<p>Most issues that the utility would flag were ones that I was able to fix. Rules like "CA1063 Implement IDisposable correctly" and "CA2000 Dispose object before losing scope" are easy to correct. The two rules that I completely turned off were "CA1056 URI properties should not be strings" and "CA1062 Validate arguments of public methods". The former, because it was a monumental pain to convert everything in my code to URIs, but return them back to strings when sending them to different frameworks; the later, because it did not <a href="http://geekswithblogs.net/terje/archive/2010/10/14/making-static-code-analysis-and-code-contracts-work-together-or.aspx">account for Code Contracts</a>.</p>
<p>The final block of rules that I am ignoring for now are "CA1020 Avoid namespaces with few types" and "CA1704 Identifiers should be spelled correctly". CA1020 is a valid notice, but the project is still in its infancy and namespaces are going to be sparce. CA1704 is flagging the words "Owin" and "POST", even though both of them are in my CustomDictionary.xml file, located in each project. I'm sure I'll stumble on a fix for this at some point.</p>
<blockquote>
<p>Code Coverage is down to only missing the .MoveNext() method calls.</p>
<p>Code Analysis is reduced to just "POST" and "Owin" identifier issues and Avoid namespaces with few types.</p>
<p>All tests are passing. Stamping this as the first official branch.</p>
</blockquote>


Vigil Base Solution

<p>In the quest to get to a Minimum Viable Product, I wanted to be able to wrap together a set of projects that would act as a complete framework for future projects. Every (nearly every) project requires users and a way for them to register and login. I had already tied myself to the <a href="https://msdn.microsoft.com/en-us/library/dn613255.aspx">IdentityDbContext</a> for user and role management. Initially, I had my base context (<a href="https://github.com/drovani/Vigil/blob/master/Vigil.Data/Vigil.Data.Modeling/VigilContext.cs">VigilContext</a>) inherit from IdentityDbContext. I had trouble coming to grips with having every project then required to bring in the Microsoft.AspNet.Identity.EntityFramework assembly. As I was explaining a completely unrelated problem to a coworker, it dawned on me that the whole point of <a href="https://msdn.microsoft.com/en-us/magazine/jj883952.aspx">Bounded Contexts</a> was to have multiple contexts, and limit them to only a narrow scope. VigilContext was not going to be used everywhere; its purpose is for database initialization and future migrations.</p>
<h2>Enter the 'Vigil' Solution</h2>
<p>This is a terrible idea, and I am probably going to regret it later, but I do not have a better way to organize everything just yet. I started a new Solution that will be all-encompassing, containing all of the projects, neatly organized into Solution Folders. This will get unwieldy, eventually, but for now I know that everything compiles, all tests pass, and code analysis returns acceptable results. Creating new solutions down the line for specific sets of projects should be rather trivial.</p>
<h2>Vigil Identity</h2>
<p>The primary usage that requires a class that inherits from IdentityDbContext is to use the rest of the Identity library and the <a href="http://coding.abel.nu/2014/05/whats-this-owin-stuff-about/">OWIN authentication</a>, including the <a href="https://msdn.microsoft.com/en-us/library/dn613257.aspx">RoleStore</a>, <a href="https://msdn.microsoft.com/en-US/library/dn613259.aspx">UserStore</a>, <a href="https://msdn.microsoft.com/en-us/library/dn896559.aspx">SignInManager</a>. Therefore, a new project, created with the same naming pattern in the based modeling project, has a context that inherits from IdentityDbContext and all of the customized classes that inherit from the Identiy and Owin generics. The most common way of managing users is through a web application. Which means that any ancillary projects that do not actually manage users will be able to have bounded contexts that do not include the Identity assembly.</p>
<h2>Got Ahead of Myself - Vigil.Web</h2>
<p>I was so excited about being able to add and edit users that I jumped ahead and created a new web project utilizing the Owin context. What a terrible mistake that was. I spent too much time focused on converting the default template to utilize all of my Vigil classes, and then suddenly stressed over not having tests for this new web project. Then I got myself buried under needing to figure out how to mock a Role Store, User Manager, and User Store in memory; and then how to start a whole test Owin context; which lead to attempting to create a mock Owin server; which lead to despair and two months since my last post.</p>
<h2>Paying Down Debt</h2>
<p>Like missing a payment on a credit card, I need to get this debit under control right away. I cannot just make the minimum payment and figure out later how to pay off the balance and exploding interest. I am going to target just the unit testing surrounding the Identity Model project. Much of this will come from looking at the source code for the Identity Framework, and learning a lot from that.</p>
<p>That is my update - not much to say except for reminding myself to post more often, and make a meaningful, complete contribution to the project before spinning out of control.</p>
<blockquote>
<p>Moved files around to better keep a uniform folder structure. Reduced the solutions down to one, though this will probably go back up once executables need creating.</p>
<p>Started adding testing framework for the OWIN and app server to be able to test Identity controllers.</p>
</blockquote>


Letting Users Get Ahead Of Me

<p>A friend forwarded me an article from Runner's World (written by editors at Men's Health) titled "<a href="http://www.runnersworld.com/workouts/8-true-tests-of-your-overall-fitness">8 True Tests of Your Overall Fitness</a>". The article describes the test, drones on about the author's experiences, and then gives some helpful tips on how to meet the test objectives. I wanted a quick chart that I could easily reference, so I'll just post it here. The 30 pound dumbbells and 315 pound deadlift assumes 200 pound body weight.</p>
<p>| | STANDARD |
| STIFF ARMS PLANK | 10 seconds |
| BROAD JUMP | 7 feet |
| SQUAT, HAMMER CURL, OVERHEAD PRESS | 20 reps in 60s, 27 lb |
| FACING WALL SQUAT (2 IN) | 1 squat |
| BEEP TEST | Level 12 |
| CLAPPING PUSHUP | 10 |
| DEADLIFT | 315 lbs |
| SIT AND REACH | 17 inches |</p>
<p>My goal is to update these with my actual figures over the rest of the summer training season. most of the day fixing all of the question marks.</p>


Rovani's Sandbox

Blog Posts - Page 11