All Things (v8)

Keeping any application healthy and under control as it grows requires attention to the application’s organization and structure among other things. With DNSimple I’ve been spending some time thinking about how to reduce the size and complexity of some of the larger classes. The impetuous for this refactoring is to make the code easier to understand and easier to test. For the later the goal is to eventually be able to test business logic without needing to load the entire Rails environment.

I currently am trying two approaches to extracting logic into modules. First, I have created a directory in lib where extracted modules will live. I choose to call this directory logic since essentially I’m trying to use it as a place to store logic (as opposed to storing code that describes data models, which will remain in the app/models directory. For simpler classes that only have a small amount of logic I am extracting all of the logic into a single file with the same name as the existing model. For example, for a Contact model the logic would go into a Logic::Contact module. This module is then mixed back into the module. Here is a (somewhat contrived) example:

Before the extraction:

class Contact < ActiveRecord::Base
  belongs_to :user

  def name
    "#{first_name} #{last_name}"
  end
end

After the extraction:

class Contact < ActiveRecord::Base
  include Logic::Contact
  belongs_to :user
end

module Logic
  module Contact
    def name
      "#{first_name} #{last_name}"
    end
  end
end

This is the simplest form of extraction. Beyond this however is another form of extraction that I am using in cases of larger, more complex classes. In this case I group together some of the logic into a module, usually naming it so it describes the behavior. For example, I have a module in DNSimple called Logic::Domain::Renewable which contains logic for domain renewal.

class Domain < ActiveRecord::Base
  # ...lots of code...
  def auto_renew?
   registry_domain.auto_renew?
  rescue => e
    logger.error e
    false
  end
  # ... more code ...
end

Becomes

class Domain < ActiveRecord::Base
  include Logic::Domain::Renewable
end

module Logic
  module Domain
    module Renewable
      def auto_renew?
       registry_domain.auto_renew?
      rescue => e
        logger.error e
        false
      end
    end
  end
end

The beauty of extracting in this way is that the different behaviors required by the system seem to align nicely into modules which make it much easier to locate code as I continue to develop the system.

So what might the tests look like after these extractions? I already have a fairly comprehensive test suite for DNSimple (yes, there are gaps) so it already is a little bit slow (although not as slow as it would eventually become). With the extractions I can began to test the logic in isolation. For example:

require 'lib/logic/contact'

class FakeContact
  include Logic::Contact
  attr_accessor :first_name, :last_name
end

describe Logic::Contact do
  subject do
    contact = FakeContact.new
    contact.first_name = "Anthony"
    contact.last_name = "Eden"
    contact
  end

  it "has a name" do
    subject.name.should eq("#{subject.first_name} #{subject.last_name}")
  end
end

What I’m doing here is creating a contact class that is not in any way tied to ActiveRecord. This allows me to completely bypass the Rails loading process and these logic tests will run extremely fast. If you take this route you’ll need to make sure to use a modified spec helper that does not load the Rails environment. I call mine lightweight_spec_helper and only load what I need in it.

In closing, all of this is designed to make the application code easier to manage so that I can continue to improve DNSimple and make my customers happier. All of this is really only possible because I have a decent amount of test coverage, allowing me to refactor and not blow up everything in the process. Inevitably during refactorings like this things will break, but my tests cover me and protect me from myself, and thus I can extract and improve without feeling like I’ll shoot myself in the foot.