Dependency Injection with LittleBoxes

• Manuel Morales
• Lead Ruby development at Workshare
• 7+ years experience Ruby
• manuelmorales@gmail.com

Dependency Injection with LittleBoxes

UsersController

User

• Big classes
• Highly coupled (non re-usable)
• Adding features by changing these classes

how I started writing Ruby

a completely different picture

you choose

HttpClient

AnalyticsClient

• We have one AnalyticsClient
• We have to extend the behavior to support signed requests

decoupling and re-using

how do we inject?

AnalyticsClient.http_client = Typhoeus

Configuring the class

analytics_client.submit(name: 'SignUp', http_client: Typhoeus)

As an argument

client = AnalyticsClient.new(http_client: Typhoeus)

Configuring the instance

The caller decides

Common in Rails with initializers

Classes are singletons

Most flexible

assumption

• We build structure that represents your application config.

• Let this structure build the instances

• And configure them

• We can achieve the picture that we imagined before

enter LittleBoxes

• Light library ~300 lines of code
• Provides a dependency tree that represents your application configuration
• Automatically configures your dependencies
• Lazy-loads by default

• In production for more than a year
• 8 services running
• Go-to library for new μservices in Ruby

let() is for memoizing

# box.rb

require 'little_boxes'

class MainBox
  include LittleBoxes::Box

  let(:logger) { Logger.new('application.log') }
end

analytics reporter example

require 'typhoeus'

class AnalyticsService
  def submit(event)
    response = Typhoeus.post(
      'http://example.com/events',
      body: event
    )

    response.code == 201
  end
end

manual injection

class AnalyticsService
  attr_accessor :http_client
  attr_accessor :server_url

  def initialize(http_client:, server_url:)
    @http_client = http_client
    @server_url = server_url
  end

  def submit(event)
    response = http_client.post(
      "#{server_url}/events",
      body: event
    )

    response.code == 201
  end
end

config-logic separation

class AnalyticsService
  attr_accessor :http_client
  attr_accessor :server_url

  def initialize(http_client:, server_url:)
    @http_client = http_client
    @server_url = server_url
  end

  def submit(event)
    response = http_client.post(
      "#{server_url}/events",
      body: event
    )

    response.code == 201
  end
end

class MainBox
  include LittleBoxes::Box

  let(:analytics_service) do |box|
    AnalyticsService.new(
      http_client: box.http_client,
      server_url: box.server_url
    )
  end

  let(:http_client) do
    require 'typhoeus'
    Typhoeus
  end

  let(:server_url) { "https://example.com" }
end

letc() auto-configures

class AnalyticsService
  attr_accessor :http_client
  attr_accessor :server_url

  def initialize(http_client:, server_url:)
    @http_client = http_client
    @server_url = server_url
  end

  def submit(event)
    response = http_client.post(
      "#{server_url}/events",
      body: event
    )

    response.code == 201
  end
end

class MainBox
  include LittleBoxes::Box

  let(:analytics_service) do |box|
    AnalyticsService.new(
      http_client: box.http_client,
      server_url: box.server_url
    )
  end

  let(:http_client) do
    require 'typhoeus'
    Typhoeus
  end

  let(:server_url) { "https://example.com" }
end

How does this work?

class MainBox
  include LittleBoxes::Box
  letc(:analytics_service) { AnalyticsService.new }
  let(:http_client) { require 'typhoeus'; Typhoeus }
  let(:server_url) { "https://example.com" }
end

# class_dependency() for class dependencies

class_dependency(:logger)


# default values with callbacks

dependency(:log) { Logger.new('/dev/null') }
dependency(:log) { |box| box.logger }


# then() callbacks to override dependencies by hand

letc(:analytics) { AnalyticsService.new }.then do |service, box|
  service.logger = box.debug_logger
end


# get() and getc() don't memoize

get(:service_url) { 'http://example.com' }


# eager_let, eager_get, etc. to force them to run at boot time

eager_let(:aws_sdk) do
  require 'aws-sdk'
  Aws.use_bundled_cert!
  Aws
end

Other features

Tree structure

class MainBox
  include LittleBoxes::Box

  let(:logger) { Logger.new('./todos.log') }
  let(:http_client) { require 'typhoeus'; Typhoeus }

  let(:todos_model) { Todo }
  let(:todos_create_endpoint) { TodosCreateEndpoint.new }
  let(:todos_list_endpoint) { TodosListEndpoint.new }
  let(:todos_delete_endpoint) { TodosDeleteEndpoint.new }

  letc(:analytics_service) { AnalyticsService.new }
  let(:analytics_url) { "https://example.com" }
end

Tree structure

class MainBox
  include LittleBoxes::Box

  let(:logger) { Logger.new('./todos.log') }
  let(:http_client) { require 'typhoeus'; Typhoeus }

  box(:todos) do
    let(:model) { Todo }

    box(:endpoints) do
      let(:create) { TodosCreateEndpoint.new }
      let(:list) { TodosListEndpoint.new }
      let(:delete) { TodosDeleteEndpoint.new }
    end
  end

  box(:analytics) do
    letc(:service) { AnalyticsService.new }
    let(:url) { "https://example.com" }
  end
end

MainBox

todos

model

create

endpoints

list

delete

client

logger

service

url

analytics

Tree structure

class TodosBox
  include LittleBoxes::Box

  let(:model) { Todo }

  box(:endpoints) do
    let(:create) { TodosCreateEndpoint.new }
    let(:list) { TodosListEndpoint.new }
    let(:delete) { TodosDeleteEndpoint.new }
  end
end

class MainBox
  include LittleBoxes::Box

  box :todos, TodosBox
  box :analytics, AnalyticsBox
  let(:http_client) { require 'typhoeus'; Typhoeus }
  let(:logger) { Logger.new('./todos.log') }
end

• Easy to explore
• No namespacing
• Resolution bubbles up
• Overrides at sub-tree

How to Test?

RSpec.describe AnalyticsService do
  let(:service) do
    AnalyticsService.new http_client: http_client, server_url: url
  end

  let(:url) { 'http://example.com' }
  let(:event) { {name: 'UserCreated'} }
  let(:http_client) { double(:http_client, post: response) }
  let(:response) { double(:response, code: 201) }

  it 'posts the event' do
    expect(http_client).
      to receive(:post).
      with('http://example.com/events', body: event)

    service.submit event
  end
end

Unit testing

• Test business logic
• Fully isolated
• Superfast

require_relative '../helper'
require 'rack/test'

RSpec.describe 'API' do
  include Rack::Test::Methods

  let(:box) { TodosBox.new }
  let(:app) { box.rack_app }

  describe 'GET /todos' do
    it 'returns 200' do
      get '/todos'
      expect(last_response.status).to eq 200
    end
  end
end

Integration testing

• Test the configuration indirectly
• The box is new for each test
• There cannot be leaks of configuration
• Lazy-loading allows the tests to be fast

Drawbacks

• Debugging and exploring code becomes  more tedious
  • Class => Class => Class
  • Class => Box => Class => Box => Class
• ​Takes time to get used to

Summary

• All dependencies injected at an application level by default
• Objects define what they need
• Separates configuration from business logic
• Behavior is extended by adding objects, not changing them
• Behavior is changed by moving objects and configuring them
• Load things only when needed, not all at the beginning
• We rely on instances much more than we do in classes

...

a completely different way

Questions?

• manuelmorales@gmail.com
• @manuelmorales twitter
• github.com/manuelmorales

github.com/manuelmorales/little-boxes