Current Time
Obtaining the current time with Time.now is a classic example of a side effect. Code relying on accessing system time is harder to test. One possible solution is passing time around explicitly, but using effects can save you some typing depending on the case.
Providing and obtaining the current time is straightforward:
require 'dry/effects'
class CurrentTimeMiddleware
include Dry::Effects::Handler.CurrentTime
def initialize(app)
@app = app
end
def call(env)
# It will use Time.now internally once and set it fixed
with_current_time do
@app.(env)
end
end
end
###
class CreateSubscription
include Dry::Efefcts.Resolve(:subscription_repo)
include Dry::Effects.CurrentTime
def call(values)
subscription_repo.create(
values.merge(start_at: current_time)
)
end
end
Providing time in tests
A typical usage would be:
require 'dry/effects'
RSpec.configure do |config|
config.include Dry::Effects::Handler.CurrentTime
config.include Dry::Effects.CurrentTime
config.around { |ex| with_current_time(&ex) }
end
Then anywhere in tests, you can use it:
it 'uses current time as a start' do
subscription = create_subscription(...)
expect(subscription.start_at).to eql(current_time)
end
To change the time, call with_current_time with a proc:
it 'closes a subscription with current time' do
future = current_time + 86_400
closed_subscription = with_current_time(proc { future }) { close_subscription(subscription) }
expect(closed_subscription.closed_at).to eql(future)
end
Wrapping time with a proc is required, read about generators below.
Time rounding
current_time accepts an argument for rounding time values. It can be passed statically to the module builder or dynamically to the effect constructor:
class CreateSubscription
include Dry::Effects.CurrentTime(round: 3)
def call(...)
# value will be rounded to milliseconds
current_time
# value will be rounded to microseconds
current_time(round: 6)
end
end
Time is fixed
By default, calling with_current_time even without arguments will freeze the current time. This means current_time will return the same value during request processing etc.
You can "unfix" time with passing fixed: false to the handler builder:
include Dry::Effects::Handler.CurrentTime(fixed: false)
However, this is not recommended because it will make the behavior of current_time different in tests (where you pass a fixed value) and in a production environment.
Using a custom generator
The default time provider accepts a custom generator which is a simple callable object. This way you can pass a proc with fixed time:
frozen = Time.now
with_fixed_time(proc { frozen }) do
# ...
end
Or you can change time on every call:
start = Time.now
with_fixed_time(proc { start += 0.1 }) do
# ...
end
Discrete time shifts
If you pass step: x to the handler, it will shift the current time on every access by x:
with_fixed_time(step: 0.1) do
current_time # => ... 18:00:00.000
current_time # => ... 18:00:00.100
current_time # => ... 18:00:00.200
end
You can also pass initial time:
initial = Time.new(1970)
with_fixed_time(initial: initial, step: 60) do
current_time # => 1970-01-01 00:00:00 +0000
current_time # => 1970-01-01 00:01:00 +0000
current_time # => 1970-01-01 00:02:00 +0000
end
Overriding handlers
Handlers of current time can be overridden by an outer handler if you pass overridable: true:
require 'dry/effects'
class CurrentTimeMiddleware
include Dry::Effects::Handler.CurrentTime
def initialize(app)
@app = app
end
def call(env)
with_current_time(overridable: ENV['RACK_ENV'].eql?('test')) do
@app.(env)
end
end
end
It's usually done in tests:
# Using global time
frozen_time = Time.now
puts "Running with time #{frozen_time.iso8601}" if ENV['CI']
RSpec.configure do |config|
config.include Dry::Effects::Handler.CurrentTime
config.include(Module.new { define_method(:current_time) { frozen_time } })
config.around { |ex| with_current_time(proc { frozen_time }, &ex) }
end