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


Overall Fitness In 8 Tests

<p>Another summer, another marathon season.</p>
<h2>Montrose at 6:00 am</h2>
<p>I will be continuing to be a pace leader at the Montrose site for the Chicago Area Runners Association (<a href="http://www.cararuns.org/">CARA</a>). Two years ago, I was a participant, and the social experience is what got me through training and to the start line. Last year, as a pace leader, helping to bring all of the runners through the long runs and the hot runs and the wet runs is what got me through training and to the start line. This year, I hope to bring my experience, enthusiasm, and energy to a new group of runners.</p>
<h2>Pacing at 8:30/mile</h2>
<p>I was on the fence about whether to continue pacing with the <a href="https://www.facebook.com/groups/cara69/">Six Niners</a> or move up to the 8:30/mile pace group. There was a fair amount of interest among my runners from last year in doing an 8:45/mile pace group (we would call ourselves the Eight Forty Five Bandits). By the time it came around for me to make a firm decision, the site coordinator for Montrose (<a href="http://www.athlinks.com/Athletes/173452181">who shall</a> <a href="https://www.facebook.com/kim.maves">not remain</a> <a href="https://twitter.com/kimmaves">nameless</a>) had already told the front office to put me down for the faster group. Thus, the decision was made for me.</p>
<h2>Running in Saucony Kinvara Shoes</h2>
<p>Over the winter, I added a pair of <a href="http://www.saucony.com/en/kinvara-5/12219M.html?dwvar_12219M_color=S20238-1">Kinvara 5 shoes</a> to my rotation. I would do my long runs in the Kinvara pair and my weekly runs in one of two pairs of Nike Air Zoom Pegasus 30+ (which they don't make anymore). By the end of training, I had switched almost entirely to the Kinvara shoes. My calves would be extremely tight the day or two after each Saturday run, but work itself out by Wednesday or Thursday. However, once I started doing my weekday runs in the shoes with the smaller drop, my calves recovered even faster. My form has improved as a result, my hips and knee (i.e. IT band) are less of an issue, and the shoes just look faster. The weight difference between the two models is amazing and noticeable while running. I am looking forward to switching entirely to the lighter shoe. I will be buying a second pair of Kinvara 5 shoes for the summer, and probably add a pair of Kinvara 6's to wrap up training and take to the Chicago Marathon in October.</p>
<h2>Increased Miles, Decreased Days</h2>
<p>Due to changes in my scheduling compared to last year, I will be changing my running schedule from the <a href="http://files.ctctcdn.com/cf1b22b5001/cd6f0faa-23b4-4e57-b4cb-b36accdf6773.pdf">official book</a>. I am planning on doing the following:</p>
<ul>
<li>Sunday: Recovery run as planned in Advanced (9:00/mile)</li>
<li>Monday: Moderate run as planned in Advanced (8:30/mile)</li>
<li>Tuesday: Speed Training (whatever Coach tells us) or Day Off (depends on social obligations)</li>
<li>Wednesday: Short Morning Run or Day Off - if I take Tuesday off, I'll do some speed work in the morning (6:45/mile) before I leave for work.</li>
<li>Thursday: Tempo runs, mileage from Intermediate plan (7:20/mile)</li>
<li>Friday: Day Off</li>
<li>Saturday: Long Run as planned in Advanced + 2 miles (8:30/mile)</li>
</ul>
<h2>Best Laid Plans…</h2>
<p>…and all that jazz. I'll see how this goes, and adjust as needed.</p>
<p>The only race between now and the Chicago Marathon is the <a href="http://www.runningguru.com/EventInformation.asp?eID=13394">Burgers &#x26; Beer 5k race</a> (need to beat 20:47 for a PR). I may squeeze in a half marathon on a Sunday, but that is still open for debate.  After Chicago is the <a href="http://www.rundisney.com/disneyworld-marathon/#dopey-challenge">Disney Dopey Challenge</a> and then <a href="https://results.chronotrack.com/event/results/event/event-19034">F^3 Lake Half Marathon</a> race in January (it is a busy month).</p>


Let's Do the Time Warp Again

<p>I have found that it is better to put structure in place around a project before going hog wild on implementation. While I recognize that some practices grow organically, a healthy amount of structure up-front can save a project from technical bankruptcy down the line. The two tools that I use early and often are interfaces and contract classes.</p>
<h2>Interfaces and Contract Classes</h2>
<p>There are a collection of interfaces that I regularly utilize throughout most projects.</p>
<ul>
<li>ICreated
<ul>
<li>VigilUser CreatedBy</li>
<li>DateTime CreatedOn</li>
</ul>
</li>
<li>IModified : ICreated
<ul>
<li>VigilUser ModifiedBy</li>
<li>DateTime? ModifiedOn</li>
<li>bool MarkModified(VigilUser, DateTime)</li>
</ul>
</li>
<li>IDeleted
<ul>
<li>VigilUser DeletedBy</li>
<li>DateTime? DeletedOn</li>
<li>bool MarkDeleted(VigilUser, DateTime)</li>
</ul>
</li>
<li>IOrdered
<ul>
<li>int Ordinal</li>
</ul>
</li>
<li>IEffective
<ul>
<li>DateTime EffectiveOn</li>
<li>bool SetEffectiveOn(DateTime)</li>
</ul>
</li>
<li>IEffectiveRange : IEffective
<ul>
<li>DateTime EffectiveUntil</li>
<li>bool SetEffectiveRange(DateTime, DateTime)</li>
</ul>
</li>
</ul>
<h2>The Obvious — ICreated, IModified, IDeleted, IOrdered</h2>
<p>These four interfaces serve to ensure that all properties are identically named throughout the solution. They also serve as a guide to future developers about what restrictions should be placed on the class. Every class that persists data to storage should implement ICreated — everything was created by someone and at some time.  An object that doesn?t implement IModified should never actually be modified. A class with IDeleted should not have the records actually removed from storage, but just fill in these fields to flag them as deleted. IOrdered means we know to set a default sort on the Ordinal field.</p>
<h2>Instead of Deleting It — Effective It!</h2>
<p>For values where we need historical data to be easily accessible, such as changing schedules or payment information, an interface is created to track the EffectiveOn date. Starting at that specific date and time, the new record becomes effective. There needs to be some way to group the different records, which is usually performed with a header type table. By definition, there can only be one effective record at any given date.</p>
<p>An example of its use is storing the payment information for a recurring transaction. The historical data for payment information is useful when looking into the past, and frequently the patron may want to change the payment option effective some future date. However, at no point will two or more payment methods be active. By implementing the IEffective and ICreated, the details of who made the change (and when) fully replace any functionality that might be lost by not implementing IModified.</p>
<h3>Need Multiple, Overlapping Effectives — Range It!</h3>
<p>When multiple records need to have their history saved or allow for changes effective in the future, the IEffectiveRange comes into utility. For IEffective records, the end of their effectiveness is the beginning of the next record?s effective date. However, for classes where there can be multiple records that come and go, an explicit range is required. This is useful for line items on a gift ? do see when any given detail was the authoritative record, especially useful after the gift has been posted and receipted.</p>
<h3>Contract Classes For</h3>
<p>I battled back and forth with whether to include the shell for code contracts with every interface I write, or to only build it out when needed. I quickly found that I was including, at minimum, a contract invariant method on each interface, so I decided to just make it a standard part of every interface. Even if the Contract Class contains no Contracts, at least the shell is there, and I can easily add them later, as needed.</p>
<p>A quick standard I have put together is that all Contract Classes are contained in the same file as the interface, in a child namespace of ?Contracts,? and named after the interface. Keeping the classes as internal and abstract means it can only be called within the assembly,</p>
<h3>Minimum Viable Framework</h3>
<p>I finally feel that I am at a stage where I have the minimum of a framework on which I can start to build an actual product. From here, I will slowly add and expand modules, slowly drifting towards the user interface, and tool with refactoring, templating, scripting, and finding other ways that I can reduce the complexity of complex tasks.</p>
<blockquote>
<p>Added generic interfaces, and began cleaning up some Code Analysis rules from the ?All Rules? playlist.</p>
<p>—<a href="">Commit 4010e840a8b168a1ab65466fa5c61cc342b56d8e</a></p>
</blockquote>
<blockquote>
<p>Added new Code Analysis rule sets to eliminate rules that I would be ignoring anyway.
Resolved several Code Contracts and Code Analysis issues.</p>
<p>—<a href="">Commit 2b1ff8a55711cb585750d4241df9c97895b7edfc</a></p>
</blockquote>
<blockquote>
<p>Decided I didn?t like having fields for the context, testuser, and now. Put them back as variables in each test method, and added a ContractVerification(false) attribute to the whole class. I think I?m going to find myself adding that attribute to a lot of testing classes.</p>
<p>—<a href="">Commit df9e61081f22471546dd1fd1132c8ecfecc3a26c</a></p>
</blockquote>
<blockquote>
<p>Added Contract Classes for each of the Interfaces.
Created the Identity and TypeBase classes to expand the foundation of classes before working on POCO?s.
Need to add more unit tests to fill out the Code Coverage.</p>
<p>—<a href="">Commit 716da101f6da28158ab0ed52aaba037b4c027676</a></p>
</blockquote>
<blockquote>
<p>Added ExcludeFromCodeCoverage attributes to the ObjectInvariant methods in the interface contract classes.
Added tests for the TypeBase class (via inheritance through a TestTypeBase class).
Filled out the ChangeLogTests tests.</p>
<p>—<a href="">Commit bcc51aeaa46dc8780ffcd9c33f88d8ecb1c2fffd</a></p>
</blockquote>


Preemptively Structuring the Chaos

<p>All of my other marathon posts seem to have the "three parts" theme going, so it probably fits for this writing. On the second of May,
I ran the Wisconsin Marathon in Kenosha. It is combined with a half-marathon, and a delayed start 5k. I had a terrible experience, but I came away with some fantastic personal post-race analysis.</p>
<h2>1) Terrible Marathon Course</h2>
<p>Pre-race logistics were fantastic. There were plenty of port-a-pots that I was in line for less than two minutes, with only fifteen minutes before the race started. Most other races I have been to include extremely long lines that snake out even a half hour before race start. The gear check was easily accessible and close to the start line. The self-seeded corrals were large enough that there was no crowding at any of the pace signs (at least from what I could see between the 7:00/mile and the 10:00/mile corrals). The race started on time, and most people seemed to do pretty well in that first mile at keeping with their selected pace.</p>
<p>The first twelve miles shared the same course as the half-marathon. There were a few gently rolling, small hills, and the pavement was almost always in good condition. Water stops were a little far apart and a little understaffed, but it was a small race and I can accept that. Had the weather been any warmer at this point (and runners thus taking more time at the tables), it would have been a real hindrance to anyone trying to run while grabbing water. The very northern point of the course had a long bend to the right, just before the turn-around, which seemed to stretch on forever - but that's just a mental part of the course, not something I would deduct from the quality score of the course.</p>
<p>However, once the half-marathon turned around to head to their finish, the course took a complete nose-dive. Cheering was already lacking in the northern half, but it became almost non-existent in the southern half. However, I figure that is part of being a small field. One of the worst parts of the course where patches on gravel. Not that nicely packed, small grain gravel - no, this was freshly dumped, large, pointy rocks with sharp edges that jam into your foot through the thin racing shoes. I felt really bad for anyone running in minimal or five-finger shoes. That would have been just disastrous. The worst part was between miles 18 and 20. It was two long miles, at the very southern point in the race, that were completely without shade and on freshly laid, sticky, heat-radiating, jet black pavement $endash; with one water station. Absolute, race killing, misery. My pace was slipping going into that stretch, but that took everything out of me. I had nothing left by the time I pulled out of that awful zone.</p>
<h2>2) Poor On Course Support</h2>
<p>As I mentioned before, the water stations (with Gatorade) were small. They were also spaced a bit farther apart than I was comfortable with. Allegedly, they also ran out of Gatorade at the last two stations shortly after I had passed them (a friend who finished fifteen minutes behind me said they were out of Gatorade). I don't know if this was because of lack of volunteers or not buying enough for the size of the field, but that seems to be a huge oversight. Additionally, there was nothing but water and Gatorade on course, and one table of PowerGel around mile 19. I would have killed for a banana at each hydration station after mile 20, and I'm sure those following me were in even worse shape.</p>
<h2>3) Sad Post-Race Party</h2>
<p>The website advertises "Our race offers everything you can dream of, plus our famous Big Cheese Medal and a brat and beer at our Post Race Party!" Directly after the finish line was water in bottles (good), bananas (great), plain bagels (acceptable), and chocolate milk (the best). However, that was it (well, there might have been Gatorade, but I didn't go looking for it). The Big Cheese Medal isn't all that big - but there's a picture of cheese on it. My pet peeve is that it is the same medal for the full and the half marathon - only the ribbon is different. The brat was less than special, and cut in half and stuffed into a pita - a PITA! Who puts a brat in a pita? It goes in a bun! The only condiment options were yellow mustard and ketchup. This is Wisconsin - brats are a culinary staple. How did they screw it up this badly? And the beer was probably a 6 oz serving. Very weak.</p>
<p>Overall, I would not recommend that marathon. If you happen to be in Kenosha, first ask yourself why you're in Kenosha; then, see if you can run the half-marathon. I would have probably had a very positive race experience if all I ran was the half-marathon; it's a shame the race was so terrible on the back half of the course.</p>
<p>Random footnote: if I had run the 5k, I would have placed first overall for men, possibly first overall. The top three times were:</p>
<ol>
<li>19:25 - Leslie Patterson, 32F</li>
<li>19:54 - Samantha Helgesen, 26F</li>
<li>21:32 - Jeffery Kiekhofer, 31M</li>
</ol>


3:56:58 - 2015 Wisconsin Marathon

<p>Two key library decisions needed to be made this week: choosing the object-relational Mapping (ORM) framework, and choosing a membership provider. To cut right to the end, Entity Framework and ASP.NET Identity were the solutions that I have chosen to utilize throughout the software. This week's commit has been getting the initial implementation created, customized, and tested.</p>
<ul>
<li>Create NotImplementedAttribute</li>
<li>Extend Identity membership classes</li>
<li>Create Interface for data context</li>
<li>Create Data Context</li>
<li>Create minimal tests</li>
<li>Minor Clean ups</li>
</ul>
<h2>NotImplementedAttribute</h2>
<p>Sort of like a TODO in the code, I pepper classes that still need work, or are just a placeholder shell with this attribute. This makes it so I can easily add a Code Analysis rule to mark it as incomplete, or I can add an ObsoleteAttribute to the NotImplementedAttribute. The compiler will issue a warning and I can easily track down any places I left marked as Not Implemented.</p>
<h2>Vigil Identity Classes</h2>
<p>By default, the Identity classes use a string as the primary key. Internally, it is a serialized Guid, but I could not find a good reason why this was masked. Also, I wanted to play with inheriting the classes ? so I did exactly that. For now, the "System" classes are just the Identity classes, with a Guid key, and table names explicitly set to match the class name (thus overriding the <a href="http://stackoverflow.com/questions/29904898/classes-inherited-from-identity-objects-not-included-in-code-first-migrations">IdentityDbContext's default</a> of naming them "AspNet_____").</p>
<h2>Data Context</h2>
<p>Now is when the fun gets to start ? time to start making some actual progress towards real data.</p>
<ol>
<li>Create the IVigilContext interface, to expose the bare minimums.</li>
<li>Create the Database Context: VigilContext</li>
<li>Inherit it from the IdentityDbContext generic class (so I can use those beautiful Vigil____ classes I created).</li>
<li>Inherit it from the IVigilContext interface and implement the "AffectedBy" and "Now" properties.</li>
<li>Create three tests:</li>
<li>Initialize and Create the database ? this runs Entity Framework model validation. I wish I could find a way to do this without actually having to create the database, but I was unable to find a way to expose the EF method that runs the validation.</li>
<li>Verify that the explicit constructor is setting the AffectedBy and Now properties. It is a menial test, but it makes sure no one breaks it in the future.</li>
<li>Assert that the Set method works for at least one model. This serves two purposes ? it makes sure that the Context is calling its base class's Set method, and it makes it so that code gets covered by a test, thus passing Code Coverage analysis.</li>
</ol>
<h2>Minor Clean Up Duty</h2>
<p>I misspelled the name of the core project, spelling it "Vigi.Data.Core". This meant renaming the project, updating the Assembly name, default Namespace, the folder name (which also caused a rename on all files in the project), the namespace in existing classes, and references to the project. Thankfully, I caught it before I was creating objects that referencing those elsewhere.</p>
<p>In order to get complete Code Coverage for unit tests, I created a test just to call the constructor for the NotImplemented Attribute (it throws a NotImplemented Exception). However, the last line in that test is an Assert.Fail, which should never be reached. This causes the Code Coverage to say that line was never executed, and thus not covered. Obviously, I do not care about Code Coverage in the Testing project, so I added a codeCoverage.runsettings file, which explicitly excludes the Vigil.Testing.Data assembly from analysis.</p>
<blockquote>
<p>Added Vigil Users and Roles implementation of the Identity framework, and added two quick tests for VigilContext.</p>
<p>—<a href="https://github.com/drovani/Vigil/commit/9bca8542c5a0f099032631c133215a5bd9c28aae">Commit 9bca8542c5a0f099032631c133215a5bd9c28aae</a></p>
</blockquote>
<blockquote>
<p>Added Entity Framework and Identity Framework.
Customized the Identity objects with Vigil objects, including using a Guid as the primary key, and adding a RoleType enum. Added a .runsettings file to exclude the Vigil.Testing.Data project from Code Coverage reports. Corrected the "Vigi.Data.Core" misspelling to "Vigil.Data.Core".</p>
<p>—<a href="https://github.com/drovani/Vigil/commit/8be35473aa84138f6ee362d083dd424726345089">Commit 8be35473aa84138f6ee362d083dd424726345089</a></p>
</blockquote>
<blockquote>
<p>Added tests to validate that the Vigil* tables have the correct names, since there was a problem with them being overwritten by the IdentityDbContext.</p>
<p>—<a href="https://github.com/drovani/Vigil/commit/4b68465701f111a806a920e7ec4d12de697aeee7">Commit 4b68465701f111a806a920e7ec4d12de697aeee7</a></p>
</blockquote>


Rovani's Sandbox

Blog Posts - Page 11