The Untitled Blog

Comparing and Contrasting Moq and Rhino Mocks

2010-03-13T21:53:00.002-05:00

My friend Jon is starting a training course in an effort to quickly bring developers up to speed on test driven development. As part of this effort, he has developed a unit test suite aimed at helping folks understand Rhino Mocks, a popular testing tool. After looking through the tests and seeing a lot of the Rhino API that I wasn’t familiar with, I wondered if there were similar undiscovered nooks in my favorite mocking framework: Moq.

After getting permission, I took his tests that use Rhino Mocks and implemented them with Moq. It was a great exercise for not only learning the two APIs, but also for getting a side by side comparison of the frameworks. The differences in most cases are subtle, and ultimately I found the choice between each to be a matter of taste.

You can find Jon’s tests here, and mine here.

Points of Interest

Mocks & Stubs?

I’m in agreement with Jon that the differences between mocks and stubs are mostly semantic, and are best reserved for academic discussions. I called all the variables in my tests “mock” because the class for creating mocks and stubs with Moq is “Mock”.

API Surface

The reason I am such a fan of Moq is that the API “surface” is minimalistic. The methods I want to use most often are within clear sight and meaningful. There’s not a lot of extra jargon and noise that I have to think about. The methods that I use 20% of the time are tucked away in a manner that is still discoverable, but yet hidden enough to give me a signal that they’re not the first path I should choose.

When I want to create a mock with Moq I have one choice:

With Rhino I have several choices:

The more decisions I’m forced to make, the more disruptive the API becomes.

Jargon Watch & API Clarity

A few examples of pros/cons of the APIs

Creating a mock of a concrete class with virtual methods
…in Rhino Mocks:

In Moq:

The simplicity of Moq’s API shines. (Replay?*)

*Replay is a concept that was prevalent in prior versions of Rhino Mocks and it continues to necessitate appearances. The record/replay syntax is still available for backward compatibility, which adds to the verbosity of the API. Read more about record/replay.

Finding the arguments passed to a stubbed method
…in Rhino Mocks:

In Moq:

I prefer the Rhino syntax in this case. The concept of a “callback” is clear enough, but it is not clear that I should be using it to perform checks on passed arguments.

Feature Parity

There are some features that are exclusive to the current versions of the libraries:

Ref Arguments

Rhino Mocks provides full support for methods with Ref arguments. Moq does not seem to. (I have an ignored failing test in my code. If you know how to make it pass please let me know!)

Mocking Protected Methods

Moq provides built-in support for mocking protected methods. You can still test protected methods with Rhino mocks, but you’ll have to write some reflection code to do so.

Conclusion

I favor the style and feel of the Moq API for some of the reasons described above, but as they say: “To each his own!” Hopefully you’ll find the side by side comparison helpful in determining your preferred mocking framework.

Have I missed anything? Please let me know if I’ve misrepresented or missed critical information that would help to clarify this comparison.

Another Industry Coping with Wicked Problems

2010-03-06T17:35:00.002-05:00

Software development is full of wicked problems:

“[A wicked problem is] a problem that is difficult or impossible to solve because of incomplete, contradictory, and changing requirements that are often difficult to recognize. Moreover, because of complex interdependencies, the effort to solve one aspect of a wicked problem may reveal or create other problems.” (http://en.wikipedia.org/wiki/Wicked_problem)

So I began to ask myself how other industries handle wicked problems. The root of the problem is uncertainty. It’s hard (impossible?) to be certain that the designs we’re generating are going to produce an elegant solution. One example I found was the healthcare industry. Here’s one coping strategy:

“If we are uncertain about the relative intrinsic merits of any [different]
treatments, then we cannot be certain about those merits in any given use
of one of them – as in treating an individual patient. So it seems irrational
and unethical to insist one way or another before completion of a suitable
trial. Thus the answer to the question, ‘What is the best treatment for the
patient?’ is: ‘The trial’. The trial is the treatment. Is this experimentation?
Yes. But all we mean by that is choice under uncertainty, plus data
collection. Does it matter that the choice is ‘random’? Logically, no. After
all, what better mechanism is there for choice under uncertainty?”

Ashcroft R. Giving medicine a fair trial. British Medical Journal 2000;320:1686.

This author’s antidote to uncertainty in medicine? Learning, trial, and experimentation.

We need to test the viability of the new ideas we come up with so we can choose the best one. If only there were only some way to apply this practice to software development!

Wiring Up Subsonic via StructureMap

2010-01-28T16:38:00.001-05:00

This post is a guide to configuring Subsonic with Structuremap to ensure the easiest TDD experience possible.

The first thing I did was generate the code using the SubSonic Linq Templates.

Next, it’s just a matter of telling StructureMap all about how to make an instance of SubSonicRepository<T>.

Here’s the goo that you need to make it all wire up:

        public static void ConfigureStructureMap()
        {
            ObjectFactory.Initialize(x =>
                {
                    x.UseDefaultStructureMapConfigFile = false;
                    x.Scan(scan =>
                    {
                        scan.WithDefaultConventions();
                        scan.TheCallingAssembly();
                        scan.AssemblyContainingType<IRepository>(); //Scans the Subsonic.Core assembly
                    });
                    x.ForRequestedType<IQuerySurface>().TheDefault.Is.ConstructedBy(c => new SomeDB()); //Gen'd by SubSonic
                    x.ForRequestedType<IDataProvider>().TheDefault.Is.ConstructedBy(c => ProviderFactory.GetProvider("A_Name_Of_A_Connection_In_Config"));
                    x.ForRequestedType(typeof(IRepository<>)).TheDefaultIsConcreteType(typeof(SubSonicRepository<>));
                }
            );
        }

IRepository<T> and SubSonicRepository<T> are both shipped in the SubSonic.Core DLL, so there’s no real work to do there.
SomeDB() is a class generated by the Linq Templates mentioned above.
The string passed to ProviderFactory.GetProvider(“”) is just the name of a connection that you define in your .config file. You’ll see all this in the examples you downloaded when getting the bits.
The last line of the config tells StructureMap to map the open generic type to a concrete generic type. For instance, when you request IRepository<Customer> StructureMap will give you a Repository<Customer>.

Now you can use constructor injection or ObjectFactory.GetInstance<T>() to get a concrete ready-to-go SubSonic repository.

Values – Practices - Tooling

2010-01-24T20:38:00.001-05:00

Something I heard recently really resonated with me and has already guided me on a few decisions lately. I’m writing it down here because this idea has really caused a revolution in my mind.

The quote is this:

Values lead us to

Practices which mandate

Tooling

This envelops a lot of thinking and emotion I’ve had in my career as I’ve made choices about how to develop software that I haven’t been able to verbalize. When I was young in my career as a developer I had that phrase completely inverted. I made most of my decisions based on the tooling I was given. For example: when I discovered how to generate 5000 lines of source code to do my database access I immediately leapt and made all my design decisions around that optimization. Even when my code got complex and unreadable I just kept on thinking about how much time that generated code saved me. “Certainly the time I’ve saved is paying for the sins I’m committing as I add line number 687 to this method!”

What are My Values?

After introspecting on this question I came up with 5 core values I have as a software craftsman (in no order):

Quality (clean code that works)
Simple designs
Learning
Creativity
Team

These values have led me to these practices:

Code designed by testing (TDD)
Question abstractions before implementation
Simple team communication mechanisms
Continuous integration
Practice (Execute, assess, learn, repeat)
Improving
Teaching

And ultimately because of these practices I use these tools:

Low-friction source control – supports continuous integration and team integration
Kanban board – supports simple communication
Keyboard shortcuts wherever possible – continuous improvement
Automated scripts - to take care of tasks requiring no creativity
Frameworks that make testing user code easy
Continuous integration applications
…and other frameworks/libraries/IDEs/languages that support my core values

These tool choices have to be constantly re-evaluated. The idea is that I’m constantly pushing to make the optimal solution feasible so that I’m supporting my values as closely as I can.

Hat tip to Dave Laribee and Steven Harman for sharing this thought at Codemash 2010!

Career Goals For 2010 And Inspirations From 2009

2009-12-22T13:50:00.001-05:00

Keep An Eye Out For Simple

Put the user first.
Simple is almost always better for software users. If your system requires a manual, go back and rethink the user experience elements of your design.

Decisions are made simple by keeping one eye on the value stream.
Daily development and planning decisions are easy when you consider yourself as part of the bigger picture. You’re probably employed by someone who wants to make or save money, right? Get an idea for what that value stream looks like, and then optimize it.

Be suspicious of frameworks that promise quicker results.
The lesson I’ve learned here is to understand the abstraction. When you’re utilizing an abstraction you’re deciding what you can assume. Make the decision a conscious one.

Cease To Acknowledge Irrelevant Concepts

‘Jr’, ‘Sr’, or ‘Architect’ next to job titles.
What do these designations mean? Rhetorical question.
I recommend “apprentice, journeyman, master”. These titles add communication and meaning to responsibilities of individuals on a team. It’s also a reflection of what should be a team’s primary goal: to learn.

Programmer as laborer.
Best explained by this article.

Estimating in hours.
We all know that estimating in hours is dumb… so why continue to justify it’s existence as a professional developer? What’s the alternative? Derive your release schedule. Research more by reading this book.

Always Be Improving

Be part of a team, and build a culture of learning.
My conviction is that only established enduring teams can really approach greatness at building software. Swapping developers from project to project is a recipe for mediocrity.

Fun With Data: SQL Server Unpivot

2009-11-05T21:49:00.001-05:00

My dad ran for a township trustee seat this past election, so I helped him organize some data he got from the Board of Elections. I massaged and finagled it into a SQL Server table in the format seen below:

This table has all registered voters for the township he was running in.

I started to wonder about the frequency that people vote. How many people voted 0/4 years, 1/4 years, 2/4 years, etc.:

Well, lucky for me I’m working with Paul Montgomery who happens to be a whiz at all things SQL Server and he gave me a hand.

The first step in solving this challenge is manipulating the data so each voter has one row per year voted. Paul pointed me to the UNPIVOT keyword. UNPIVOT rotates columns into rows:

select * from (
SELECT * FROM Voters) src
UNPIVOT (Voted FOR [Year] IN (Voted200905, Voted200811, Voted200803, Voted2007)) unpvt

This query gives me this result:

Now I can group by the voter’s ID and sum the times they voted.

SELECT VoterID, Years = SUM(CAST(Voted AS TINYINT)) FROM (
SELECT * FROM Voters.dbo.Voters) src
UNPIVOT (Voted FOR [Year] IN (Voted200905, Voted200811, Voted200803, Voted2007)) unpvt
GROUP BY VoterId

Now I just need to group by the “Years” column and I’ve got my result:

SELECT Years, count(1) as Voters FROM (
    SELECT VoterID, Years = SUM(CAST(Voted AS TINYINT))
        FROM (SELECT * FROM Voters.dbo.Voters) src
        UNPIVOT (Voted FOR [Year] IN (Voted200905, Voted200811, Voted200803, Voted2007)) unpvt
        GROUP BY voterId) voters
GROUP BY Years
ORDER BY Years

Only 355 of the 5091 registered voters (which already is a small subset of the population) voted in all 4 of the elections I had data for!

ASP.Net MVC Firestarter

2009-10-19T12:09:00.001-04:00

Tim Wingfield and I gave a talk on “Intro to ASP.Net MVC” in Cincinnati as part of the MVC Firestarter. Slides/code and everything else from each one of the talks has been posted to the CINNUG website.

If you had any questions you were burning to ask but didn’t have time, you know how to reach me.

An Opinion on Repository

2009-07-06T09:30:00.001-04:00

First, what is a repository?

…Therefore, use a Repository, the purpose of which is to
encapsulate all the logic needed to obtain object references. The
domain objects won’t have to deal with the infrastructure to get
the needed references to other objects of the domain. They will
just get them from the Repository and the model is regaining its
clarity and focus.

Excerpt from Domain Driven Design Quickly

So what the author is saying is that the repository’s (single) responsibility is to encapsulate the logic for obtaining object references. What that means to me is that the class utilizing the repository should be querying it in clear terms, such as:

_repository.GetPendingOrdersFor(customer);

This interface keeps the behavior of the method calling the repository focused on it’s job, and eliminates querying logic. Not only that, but the intention of the code is clear and even human(non-developer) readable.

The alternative is:

_respository.Query<Order>(o => o.CustomerID = customer.CustomerID && o.Status == OrderStatus.Pending);

Here’s how these options would look as an interface.

Just one man’s opinion. What do you think?

ASP.Net MVC: Intro To MVCContrib TestHelpers

2009-07-01T09:30:00.000-04:00

MVCContrib contains an assembly specifically built to provide help when unit testing ASP.Net MVC controller actions. This is a very condensed guide to what you can accomplish using each helper method.

Test View Rendering

Test that a view is being rendered from the action:

_controller.List().AssertViewRendered();

…for a particular view

_controller.List().AssertViewRendered().ForView("SomeViewName");

…with a view model of the correct type

_controller.List().AssertViewRendered().ForView("List").WithViewData<SomeType>();

Test PartialView Rendering

Test that a partial view is being rendered from the action:

_controller.ShowAsteroid().AssertPartialViewRendered();

…for a particular view

_controller.ShowAsteroid().AssertPartialViewRendered().ForView("Asteroid");

…with a view model of the correct type

_controller.ShowAsteroid().AssertPartialViewRendered().ForView("Asteroid").WithViewData<AsteroidModel>();

Test Redirects

Assert that the action redirects to the correct action:

_controller.AddFormStar().AssertActionRedirect().ToAction("List");

…for an action on a different controller:

_controller.AddFormStar().AssertActionRedirect().ToController("SomeController").ToAction("List");

Easily Stub HttpContext Variables

The TestHelper library contains a class (TestControllerBuilder) that builds up a complete context for your controller to operate within. This gives you the ability to easily mock anything that you would normally access from HttpContext. Here’s an example of usage:

The _builder variable is what contains all of the dictionaries for Session, ViewData, etc. that you can use to set up all of your stubs. Example:

The code in the ActionUnderTest method will now be able to access all of the variables just set up in the test. Couldn’t be easier!

Tip For Keeping ASP.Net MVC Views Easy To Read

2009-06-24T08:00:00.001-04:00

ASP.Net MVC views are harder to read when they’re built with a lot of escapes between script and HTML, such as:

There’s really just no good way to make that easy to read using this approach.

Using the MVC Futures Repeater Control

Server controls and MVC just don’t sound like they’d go together, but if used for good I believe they can really serve a useful purpose. The following code snippet achieves the exact same result as above, but reads much cleaner:

The MVC Futures repeater control gives me a way to display repeating data with a template. The control is “bound” to the Model.Items collection because I set the name of the repeater to “Items”.

To get a reference to this control you need to include a reference to the MVC Futures assembly in the web.config:

The complete solution with this code can be downloaded here:

Run Your Tests With A Keystroke

2009-06-22T08:00:00.000-04:00

Today I was looking for a way to run my unit tests with a keyboard shortcut. I got really tired of grabbing the mouse just to click a button (wow I’m lazy):

I knew there had to be a way to kick off a single test using ReSharper – and after a little digging I found the solution.

The magic lies in these 4 keyboard mappings. Assign them to something that makes sense to you, and enjoy the benefit of removing just a little more friction from your TDD experience.

Previous ReSharper keyboard shortcut tips:

Part 9 – Help When Yellow Screens Happen
Part 8 – Bird’s Eye View of Class Files
Part 7 – Add New Files Quickly
Part 6 - Move Extracted Interfaces to Their Own File using ReSharper
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

Resharper Help When Yellow Screens Happen

2009-06-18T08:00:00.001-04:00

Ran across a great utility in Resharper to help with code navigation. It comes in particularly handy when you come across one of these:

To get your app back to working order, Resharper will analyze the stack trace and then show hyperlinks so you can jump into the code that dealt the problem. Here’s how:

Now go back to Visual Studio and launch the Resharper feature (Intelli-J bindings use CTRL+SHIFT+E, Visual Studio bindings use CTRL+E, T).

When you launch the Stack Trace Explorer, your copied stack trace will already be inserted into the window and all of your user code class names/line numbers will be turned into hyperlinks. You can now easily click through to your code to see what’s up:

Previous ReSharper keyboard shortcut tips:

Part 8 – Bird’s Eye View of Class Files
Part 7 – Add New Files Quickly
Part 6 - Move Extracted Interfaces to Their Own File using ReSharper
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

Rendering A Modal Dialog with ASP.Net MVC

2009-06-15T22:21:00.001-04:00

One of the most requested ‘Web 2.0’ features by users is the ability to pop up a “modal” dialog to the user. There are a couple ways you could implement this functionality, but I’m going to show you a really easy way to do it with ASP.Net MVC. (Hat tip to Jon Kruger for sharing this idea with me.)

Start with a very simple controller action:

Nothing spectacular going on here. The “RandomModal” string points to a ASCX file that is in the views directory, and the second parameter is the model that you want the partial view to render:

And finally, on the view that is hosting the modal dialog there is a chunk of javascript that makes the call, throws the returned DOM elements into a parent div, and displays the div as a dialog:

Another place you could implement this pattern is on a grid. A common request is to click on a row and view more detailed information about the record. To implement this all you’d need to do is stash a row identifier on the html row, and pass that back to the controller on click. Something like this:

The complete solution with this code can be downloaded here:

Resharper: Bird’s Eye View Of Class Files

2009-06-13T07:42:00.001-04:00

When I’m in a unit testing class file, sometimes I have multiple classes in the same file and the file gets pretty large. It’s times like these when the file structure navigation shortcut comes in handy. For users with their keybindings set to the Visual Studio scheme, the shortcut is CTRL+ALT+F. If you’re using the Intelli-J bindings, it’s CTRL+F11.

Previous ReSharper keyboard shortcut tips:

Part 7 – Add New Files Quickly
Part 6 - Move Extracted Interfaces to Their Own File using ReSharper
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

Resharper: Add New Files Quickly

2009-06-10T08:00:00.000-04:00

If you’re adding a class, interface, struct, enum, or new folder to your project, then you can use a feature of ReSharper to add that file much quicker than using the menu commands in Visual Studio.

How do you use this simple shortcut? Select the node that you want your item to be created in in the solution explorer, and type ALT+Insert.

Previous ReSharper keyboard shortcut tips:

Part 6 - Move Extracted Interfaces to Their Own File using ReSharper
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

ASP.Net MVC: Testing Base Controller Methods

2009-06-06T09:42:00.001-04:00

The project that I’m working on now created the need to execute some logic before every controller action in the application executed. The ASP.Net MVC Controller class has a virtual method called OnActionExecuting which will allow me to do just what I needed. The only problem is that testing this bit of logic in the base controller wasn’t straightforward, and took a little research. This is the solution I came up with:

The class under test:

public class BaseController : Controller
{
    protected override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        ViewData["SomeKey"] = "Coming to you from a base controller!!";
    }
}

The test:

[TestFixture]
public class BaseControllerTests
{
    [Test]
    public void Before_executing_an_action_base_controller_should_populate_view_data()
    {
        var baseController = new BaseController();
        var baseControllerAccessor = new BaseControllerAccessor(baseController);
        var actionExecutingContextMock = new Mock<ActionExecutingContext>(); 
        baseControllerAccessor.OnActionExecuting(actionExecutingContextMock.Object);
 
        Assert.That(baseController.ViewData["SomeKey"], Is.EqualTo("Coming to you from a base controller!!"));
    }
}

The BaseController OnActionExecuting method is protected, so I had to do some jury-rigging using reflection to actually put the method under test:

public class BaseControllerAccessor
{
    private BaseController _baseController;
 
    public BaseControllerAccessor(BaseController baseController)
    {
        _baseController = baseController;
    }
 
    public void OnActionExecuting(ActionExecutingContext context)
    {
        MethodInfo methodInfo = _baseController.GetType().GetMethod("OnActionExecuting",
                                    BindingFlags.NonPublic | BindingFlags.Instance);
        methodInfo.Invoke(_baseController, new object[] {context});
    }
}

This was a bit of a pain, but the peaceful easy feeling I’m getting from knowing my code is backed up with an automated test makes it all worth it.

This code can be downloaded here.

Team Velocity: ASP.Net Webforms and MVC

2009-05-31T13:01:00.001-04:00

Since the release of ASP.Net MVC, one of the major talking points has been: When should I use MVC and/or webforms, and will it save or cost me time. These are my thoughts.

Consider the following:

Velocity is the number of feature hours (or feature points) completed in a given iteration (or time period – given that the time period is constant).

Why does it take longer to gain velocity with MVC?

As ASP.Net web developers we’ve been developing with a mammoth abstraction that’s made a ton of our design decisions for us. To achieve velocity with webforms, you really needed only a cursory understanding of how the web works. Contrast that with ASP.Net MVC, which puts developers closer to “the metal” and forces us to make intentional decisions about the design of our apps. Because of this freedom (and power) we’re also responsible for making sure we don’t make the wrong decisions, so it takes a great deal of critical thought and planning to make it what you want it to be.

Once your design and opinions have been established, velocity is likely to increase and then stabilize. Why? Because if you’re doing it right, then you’re designing with SOLID* principles in mind (something that’s extremely hard to do with webforms). Complexity is minimized and entropy is mitigated.

What’s with the sharp decrease in velocity with webforms?

Because it’s so hard to create SOLID* apps with webforms, complexity grows and grows until it’s out of hand. Release cycles go from weeks to months to quarters, and then the app that the company invested millions of dollars in needs to be rewritten because the cost to maintain and/or extend outweighs the cost to start over.

What do you think?

*SOLID principles are not new and whizbangy. They’re a different name and face on what’s been known about OO since the first OO languages, and what every CS college student should have learned in OO design 101.

Fluent NHibernate Configured Via Dependency Injection

2009-03-19T23:22:00.001-04:00

I remember having to reference this “best practice” post when setting up a new project utilizing NHibernate. What a nightmare. Thankfully, there’s been some really positive activity on the Fluent NHibernate project, and configuration has become much more straightforward. In this post I am going to share my experience configuring NHibernate using:

Fluent NHibernate
Ninject
MySQL (Configuring any common database platform is trivial once you’ve seen it done)

To get my head around the basic configuration, I read the tutorial at the Fluent NHibernate site: http://fluentnhibernate.org/

After reading the tutorial, I had a good idea of the external dependencies I’d need to “inject” into my app.

Configuring the Repository

The primary point of entry for any data transferred to and from my database is via my repository. NHibernate’s ISession is what I will interface with to make queries, so I’m going to need that object created and injected into my repository.

Example of a simple repository:

    public class Repository : IRepository
    {
        private ISession _session;
 
        public Repository(ISession session)
        {
            _session = session;
        }
 
        public void Save<T>(T entity) where T : DomainEntity
        {            
        }
 
        public T Load<T>(int id) where T : DomainEntity
        {
        }
 
        public IQueryable<T> Query<T>() where T : DomainEntity
        {
        }
 
        public IQueryable<T> Query<T>(Expression<Func<T, bool>> where) where T : DomainEntity
        {
        }
    }

The constructor of my class takes an instance of ISession. This is where the dependency will be injected into my Repository class.

Widdling down the “Best Practice” article

The most important part of an NHibernate configuration is your management of the SessionFactory and Session objects. The SessionFactory object is expensive to create, and should be made a Singleton. The ISession object should be retained for the lifecycle of the current request if you’re working on a web application. For a non-web project the lifecycle of the ISession should be kept around one per thread.

Many (if not all) of the major dependency injection frameworks offer this type of “lifecycle management” out of the box. Ninject is no exception; here is how I accomplished it:

    internal class IoCConfiguration : StandardModule
    {
        public override void Load()
        {
            Bind<IRepository>().To<Repository>();
            Bind<INHibernateSessionFactoryBuilder>().To<NHibernateSessionFactoryBuilder>().Using<SingletonBehavior>();
 
            Bind<ISession>().ToMethod(ctx => ctx.Kernel.Get<INHibernateSessionFactoryBuilder>()
                .GetSessionFactory()
                .OpenSession())
                .Using<OnePerRequestBehavior>();
        }
    }

Due to the expressive nature of the API, this code is really self-explanatory. Just for fun, compare this code with the mess from the NHibernate best practices article I mentioned eariler (http://www.codeproject.com/KB/architecture/NHibernateBestPractices.aspx).

For completeness, here is the code to configure NHibnerate via Fluent Nhibernate for a MySql database:

    public class NHibernateSessionFactoryBuilder : INHibernateSessionFactoryBuilder
    {
        private ISessionFactory _sessionFactory;
 
        public ISessionFactory GetSessionFactory()
        {
            if(_sessionFactory == null)
            {
                _sessionFactory = CreateSessionFactory();
            }
 
            return _sessionFactory;
        }
 
        private ISessionFactory CreateSessionFactory()
        {
            return Fluently.Configure()
                .Database(MySQLConfiguration.Standard.ConnectionString(c => c.FromAppSetting("DBConnString")))
                .Mappings(m => m.AutoMappings.Add(AutoPersistenceModel.MapEntitiesFromAssemblyOf<DomainClass>()
                                                .Where(w => w.BaseType == typeof(DomainEntity))
                                                .ConventionDiscovery.Add<PrimaryKeyConvention>()
                                                .WithSetup(convention => 
                                                {
                                                    convention.FindIdentity = t => t.Name == "Id";
                                                    convention.IsBaseType = type => type == typeof (DomainEntity);
                                                }
                                                )))
                .BuildSessionFactory();
        }
    }

This is all best explained by the Fluent Nhibernate wiki (which is excellently written).

All this is a first swag, and I’d love to hear how it could be improved. Please leave a comment if you’ve got any questions or if you know of a way it can be better!

Content Not Being Indexed in Sitefinity

2009-03-05T11:01:00.001-05:00

This post will be a little esoteric. I’m working on a Sitefinity project, and one of the features we wanted to implement was the built in site search module.

After configuring the search module everything appeared to be working properly, but after looking a little closer we realized that none of our site content was being indexed. The only thing that was being indexed was each page’s meta tags. I found out in one of the Sitefinity forums that you can control what gets indexed on the site by using an XML configuration file. You can find your site’s configuration file in this path: /%AppDirectory%/App_Data/Search/%IndexName%/fieldsInfoProvider.xml

Here is what the file looks like when you set up a new index:

Here’s what the attributes mean:
name= This attribute is for the reader. You can name it whatever you want.
weight= Gives weight to the content in the search results. (Eg: Items weighted higher will return higher in the search results than lesser weighted items)
indexAttribute= Use this attribute to index all tags with a certain attribute.
filterTag= Use this to tell Sitefinity that you want to index by tag name.
filterAttributes= Use this to filter the attributes by value.

In the site I am building, I want an entire HTML node to be indexed it happens to be:

<div id=”primary”></div>

So to add this content to my index, I added a field node in the fieldsInfoProvider.xml file as such:

If I wanted to add a HTML node by class, I could have changed the filterAttributes= attribute to “class:someCSSClass”. If my HTML node was a <UL>, I’d change filterTag= “UL”.

Google Chrome “Feeling Lucky Search”

2009-02-22T20:40:00.001-05:00

If you want to do a “Feeling Lucky” search from Google Chrome post haste, I’ve got a great trick for you. Check this out:

Fewer clicks, happier browsing.

Here’s how to do it:

1) Create a custom search engine in Chrome:

2) Add the search engine with these properties:

URL: http://www.google.com/search?q=%s&btnI=Im+Feeling+Lucky

3) Enjoy!!

Move Extracted Interfaces to Their Own File using ReSharper

2009-02-06T08:30:00.001-05:00

Update 2/6/09:

Thanks for @orangy for pointing out that there is an even more streamlined approach that I overlooked.

With your cursor on the concrete class use the "Refactor This" keyboard shortcut (CTRL+SHIFT+R), then X. The extract interface dialog pops.

Then use the keyboard shortcut ALT+F to change the radio button to "Place in another file". Then tab through the rest of the controls and make your selections.

Much nicer.

One thing I do commonly when developing is create a class, and then extract an interface from it. ReSharper makes that easy:

~~1) Put your cursor on the concrete class name.~~

~~2) Use ReSharper's "Refactor This" keyboard shortcut (CTRL+SHIFT+R).~~

~~3) Hit "x" on the keyboard for "extract interface".~~

~~A keyboard friendly dialog will open which will allow you to select which members get extracted out into the interface.~~

So now you have an interface sitting in the same file as your concrete class. That's perfectly acceptable, but I always prefer having each class/interface in it's own file named the same as the class/interface name. To do that, you just need to put your cursor on the interface name and hit "CTRL+Enter, Enter", to select the option for "Move to another file to match type name".

Thanks to www.twitter.com/orangy for helping me find this shortcut!!

This is part 6 of a series of posts exploring how to become a ReSharper keyboard ninja.

Previously:
Part 5 - Find the Next Error Using ReSharper
Part 4 - What To Pass?
Part 3 - Surround Your Code
Part 2 - Find Inheritors
Part 1 - Quick Documentation View

Trends For My Industry

2009-01-23T09:49:00.001-05:00

I've been doing the software consulting circuit for a while, although not too long - about 2 years. It's enough time to know that there's a lot of room for improvement, and I'm going to discuss in this blog post what trends I think will emerge as the industry matures. Many of the points I'm going to make are based on observations I've made about software quality, and how organizations will begin to value it more.

More Emphasis On Partnerships and Trust

Too many projects end in something less than success. It's time that we change perspectives on software development and become fanatical about achieving our customer's goals. What I think this means is that we completely change our business models. Instead of the old-school fixed bid or time and materials contracts, let's go for more of the incentive based contracts. In other words, I get paid when I've made you money. Doesn't that take a huge amount of trust? Yeah it does, and that's where I think we need to get. (You can do some more reading on "Agile Contracts" here.)

Incentive based contracts encourage a healthy economy between partners. There's only one goal: to make each-other successful. Now when I come to my partner and ask if it is acceptable to take care of some technical debt, or begin using Test Driven Development, he/she will know that I am only doing it because it is a true investment - and I know that it will benefit me (us!) in the future.

Less Emphasis On Methodologies

Agile, Scrum, XP, Waterfall - they all have one thing in common: they don't mean the same thing to any two people. It's all about communication. We have got to stop applying tools to the process by default and instead have one goal in mind: Keep Improving. I think we'll see companies start to understand that in order to manage a software team you have to let the software team do the managing. There are no better people to make management decisions other than your team. They're on the front-lines with the most comprehensive knowledge available, and will always make the best decision possible.

Teams will still require leadership, but leadership should begin to lean more and more on their people to do the critical thinking and solve not only software problems, but also process problems. In summary: More thinking, less blindly applying tools and/or process.

More Value Placed In Established Software Teams

It sounds reasonable to believe that a developer is a developer is a developer. You always hear how everyone is replaceable and we're just all cogs in the wheel. I'd argue that, however. Developers who have built relationships, established trust, and learned strengths and weaknesses will outperform any other team that has been banded together on-the-fly. Managers and decision makers will eventually begin to see this as they make decisions on who will build their software. Thus you'll see more software teams grow and strengthen and their services will become more valuable.

Single Responsibility Teams Will Fade

As people mature in their careers as software developers, skill sets will mature to the point where it will become expected that feature development will occur in a vertical fashion. By this, I mean that each developer on a team should be able to construct a software feature from top (UI) to bottom (Database) with minimal intervention from other developers. There will always be developers with talents that weigh more on user interface design versus skill in SQL Server (for instance), and they will be valuable as team members. But, every team member should have the ability to work independently to provide value to the paying customer.

Developers Will Provide Their Own Tools

I've come onto a customer's site on a staff aug contract to be seated at a computer that my mother would have grown frustrated with after using a word processor. This is an edge case for sure, but hopefully it illustrates that our clients don't always understand the need for quality tools. I don't blame them - it's not their area of expertise. We are brought in to fill a need, and we know the most about what we require - so we should be the ones to provide the tools necessary to do the job. There are other trades that require their craftsmen to provide their own tools, take for instance mechanics or construction workers.

Less Emphasis On Technology, More On the Domain

We know this: software does not fail to meet customer expectations because of technology. Our first goal shouldn't be to start writing code, but to understand the domain and help our customer make more money. We should be looking at their model and suggesting improvement points. We should be more than the geeks who write code, we should be looked at to solve challenges - technical or otherwise.

Less Staff Augmentation Consulting

In a couple of companies that I've consulted for on a staff-aug basis I've seen software systems that were almost literally being held together by duct-tape and paper mache. The observation I made was that the company was hiring contractors almost exclusively and that these hard working people would swoop in, get a cursory understanding of the system, and make patchwork fixes. These fixes were always just good enough to get the system operational again. And that is probably noble of them because everyone knows that in order to prove you're worth your salt is to be the hero and save the day. This model has got to end.

Agile Elevator Speech

2008-11-23T15:21:00.001-05:00

I've given quite a few "elevator speeches" about Agile. After giving each speech, I've either failed to deliver my message, or my audience failed to understand.

Well, I'm giving up on them. If I can't be successful then I don't want to add to the confusing cacophony of messages about Agile.

Stop Advocating?

No, I am too passionate about software and software teams to give up advocating Agile. So here is my plan.

I'm going to explain the prizes. It's too hard to explain the tools, so I'll give them the good stuff up front.

Why? Because it's too complex (and important) of a topic to discuss in short time. So in paraphrase here is what I'll tell them:

When constructing software as a team, I don't care what methodology you're using as long as the team can achieve these goals:

1) Fail fast.
2) Continuously improve the team.
3) Continuously reduce and eliminate waste.
4) Indicate (visually or otherwise) the teams progress.
5) Embrace change.

Agile happens to have some pretty practical tools that will get us there. If you'd like to join me for lunch, I'd be happy to tell you more!!

Testing Expressions With Moq

2008-11-18T09:07:00.001-05:00

In one of the tests I was writing using Moq, I needed to test that my repository was called with a particular expression. After struggling for a bit, I found a solution which I am sharing here in hopes that it will benefit you.

    1         [Test]
    2         public void Then_Repository_Should_Be_Queried_For_Files_In_Pending_Status()
    3         {
    4             List<JSOFile> dummyFiles = new List<JSOFile>()
    5                       {
    6                           new JSOFile() { STATUS_CD = "P", FILE_NM = "teststring"},
    7                           new JSOFile() { STATUS_CD = "Z", FILE_NM = "test.txt"}
    8                       };
    9 
   10             _repository.Expect(x => x.FindAll(It.IsAny<Func<JSOFile, bool>>()))
   11                 .Callback((Func<JSOFile, bool> del) =>
   12                 {
   13                     dummyFiles = dummyFiles.Where(del).ToList();
   14                 });
   15 
   16             _fileManagement = new FileManagement(_repository.Object, _logger.Object, _file.Object, _jsoFileReader.Object, _jsoFileParser.Object);
   17 
   18             _fileManagement.ProcessReceivedFilesToPending();
   19 
   20             Assert.That(dummyFiles.Count == 1, "Expression passed into the FindAll method was incorrect.");
   21             Assert.That(dummyFiles.FirstOrDefault().FILE_NM == "teststring");
   22 
   23             _repository.Verify();
   24         }

What am I testing?

In the method under test (Line 18 _fileManagement.ProcessReceivedFilesToPending()), I want to ensure that my repository is being queried for the appropriate objects. In this case, all "JSOFile" objects with the STATUS_CD of "P".

The meat of this test method is line 10. This line sets up an expectation that the FindAll(Func<JSOFile, bool>) method will be called from the repository object passed in via constructor (line 16, first parameter).

(_repository defined as:)

_repository = new Moq.Mock<IRepository>();

The Expect method takes a lamba expression that allows you to set an expectation on the type being mocked. In addition to setting expectations, you can also define callbacks. In this example, the callback gets fired when the class under test (_fileManagement) executes the mocked object's FindAll() method. Line 13 will receive the delegate that was passed to the _repository.FindAll. To make sure the delegate was what I expected, I execute the delegate against a list of dummy objects. On lines 20 and 21 I make sure that my list was narrowed down to the object with a status of "P".

Why go to this trouble?

In the future if my repository call gets changed, this test will fail and alert the developer that they've broken intended functionality.

Internet Explorer CSS Quirk (border-spacing)

2008-10-30T13:20:00.001-04:00

Consider the following CSS class:

.test
{
border-spacing: 0px; /*Only works in Firefox */
border-collapse: collapse; /*Works in Firefox and IE */
}

With the border spacing CSS style attribute set to zero pixels, Firefox and IE render differently:

Internet Explorer:

Firefox:

Moral: Use "border-collapse: collapse;" when you want no border spacing in your tables.