Problem z porównaniem czasu z RSpec

Używam Ruby on Rails 4 i rspec-rails gem 2.14. W przypadku mojego obiektu chciałbym porównać bieżący czas z updated_atatrybutem obiektu po uruchomieniu akcji kontrolera, ale mam kłopoty, ponieważ specyfikacja nie spełnia wymagań. To znaczy, biorąc pod uwagę poniższy kod specyfikacji:

it "updates updated_at attribute" do
  Timecop.freeze

  patch :update
  @article.reload
  expect(@article.updated_at).to eq(Time.now)
end

Po uruchomieniu powyższej specyfikacji pojawia się następujący błąd:

Failure/Error: expect(@article.updated_at).to eq(Time.now)

   expected: 2013-12-05 14:42:20 UTC
        got: Thu, 05 Dec 2013 08:42:20 CST -06:00

   (compared using ==)

Jak mogę sprawić, by specyfikacja przeszła?

Uwaga : próbowałem również następujących (zwróć uwagę na utcdodatek):

it "updates updated_at attribute" do
  Timecop.freeze

  patch :update
  @article.reload
  expect(@article.updated_at.utc).to eq(Time.now)
end

ale specyfikacja nadal nie spełnia warunków (zwróć uwagę na różnicę wartości „otrzymano”):

Failure/Error: expect(@article.updated_at.utc).to eq(Time.now)

   expected: 2013-12-05 14:42:20 UTC
        got: 2013-12-05 14:42:20 UTC

   (compared using ==)

Obiekt Ruby Time zachowuje większą precyzję niż baza danych. Gdy wartość jest odczytywana z bazy danych, jest zachowywana tylko z dokładnością do mikrosekund, podczas gdy reprezentacja w pamięci jest dokładna do nanosekund.

Jeśli nie obchodzi Cię różnica w milisekundach, możesz wykonać to_s / to_i po obu stronach swoich oczekiwań

expect(@article.updated_at.utc.to_s).to eq(Time.now.to_s)

lub

expect(@article.updated_at.utc.to_i).to eq(Time.now.to_i)

Zapoznaj się z tym, aby uzyskać więcej informacji o tym, dlaczego czasy są różne

Uważam, że używanie be_withindomyślnego matchera rspec jest bardziej eleganckie:

expect(@article.updated_at.utc).to be_within(1.second).of Time.now

tak, ponieważ Oinsugeruje, że be_withindopasowywanie jest najlepszą praktyką

... i ma więcej zastosowań -> http://www.eq8.eu/blogs/27-rspec-be_within-matcher

Ale jeszcze jednym sposobem, jak sobie z tym poradzić, jest użycie wbudowanych Railsów middayi middnightatrybutów.

it do
  # ...
  stubtime = Time.now.midday
  expect(Time).to receive(:now).and_return(stubtime)

  patch :update 
  expect(@article.reload.updated_at).to eq(stubtime)
  # ...
end

Teraz to tylko do demonstracji!

Nie użyłbym tego w kontrolerze, ponieważ odrzucasz wszystkie połączenia Time.new => wszystkie atrybuty czasu będą miały ten sam czas => mogą nie udowodnić koncepcji, którą próbujesz osiągnąć. Zwykle używam go w komponowanych obiektach Ruby podobnych do tego:

class MyService
  attr_reader :time_evaluator, resource

  def initialize(resource:, time_evaluator: ->{Time.now})
    @time_evaluator = time_evaluator
    @resource = resource
  end

  def call
    # do some complex logic
    resource.published_at = time_evaluator.call
  end
end

require 'rspec'
require 'active_support/time'
require 'ostruct'

RSpec.describe MyService do
  let(:service) { described_class.new(resource: resource, time_evaluator: -> { Time.now.midday } ) }
  let(:resource) { OpenStruct.new }

  it do
    service.call
    expect(resource.published_at).to eq(Time.now.midday)    
  end
end

Ale szczerze polecam trzymać się be_withindopasowania nawet przy porównywaniu Time.now.midday!

Więc tak, proszę trzymać się be_withindopasowywania;)

aktualizacja 2017-02

Pytanie w komentarzu:

co jeśli czasy są w skrócie? w jakikolwiek sposób sprawić, by oczekiwanie (hash_1) .to eq (hash_2) zadziałało, gdy niektóre wartości hash_1 są pre-db-times, a odpowiadające im wartości w hash_2 są post-db-times? -

expect({mytime: Time.now}).to match({mytime: be_within(3.seconds).of(Time.now)}) `

możesz przekazać dowolne dopasowanie RSpec do matchdopasowującego (więc np. możesz nawet wykonać testy API z czystym RSpec )

Jeśli chodzi o „czasy post-db”, myślę, że masz na myśli ciąg, który jest generowany po zapisaniu do DB. Proponuję oddzielić ten przypadek od 2 oczekiwań (jedno zapewniające strukturę skrótu, drugie sprawdzające czas), więc możesz zrobić coś takiego:

hash = {mytime: Time.now.to_s(:db)}
expect(hash).to match({mytime: be_kind_of(String))
expect(Time.parse(hash.fetch(:mytime))).to be_within(3.seconds).of(Time.now)

Ale jeśli ten przypadek jest zbyt często w twoim zestawie testów, sugerowałbym napisanie własnego dopasowania RSpec (np. be_near_time_now_db_string) Przekonwertowania czasu ciągu db na obiekt Time, a następnie użycie tego jako części match(hash):

 expect(hash).to match({mytime: be_near_time_now_db_string})  # you need to write your own matcher for this to work.

Stary post, ale mam nadzieję, że pomoże to każdemu, kto wejdzie tutaj w poszukiwaniu rozwiązania. Myślę, że łatwiej i pewniej jest po prostu utworzyć datę ręcznie:

it "updates updated_at attribute" do
  freezed_time = Time.utc(2015, 1, 1, 12, 0, 0) #Put here any time you want
  Timecop.freeze(freezed_time) do
    patch :update
    @article.reload
    expect(@article.updated_at).to eq(freezed_time)
  end
end

Gwarantuje to, że przechowywana data jest właściwa, bez robienia to_xlub martwienia się o wartości dziesiętne.

Możesz przekonwertować obiekt daty / daty / godziny / godziny na ciąg, który jest przechowywany w bazie danych za pomocą to_s(:db).

expect(@article.updated_at.to_s(:db)).to eq '2015-01-01 00:00:00'
expect(@article.updated_at.to_s(:db)).to eq Time.current.to_s(:db)

Najłatwiejszym sposobem obejścia tego problemu jest utworzenie current_timemetody pomocniczej testu, takiej jak:

module SpecHelpers
  # Database time rounds to the nearest millisecond, so for comparison its
  # easiest to use this method instead
  def current_time
    Time.zone.now.change(usec: 0)
  end
end

RSpec.configure do |config|
  config.include SpecHelpers
end

Teraz czas jest zawsze zaokrąglany do najbliższej milisekundy, aby porównania były proste:

it "updates updated_at attribute" do
  Timecop.freeze(current_time)

  patch :update
  @article.reload
  expect(@article.updated_at).to eq(current_time)
end

Ponieważ porównywałem hashe, większość tych rozwiązań nie działała dla mnie, więc stwierdziłem, że najłatwiejszym rozwiązaniem jest po prostu pobranie danych z hasha, który porównywałem. Ponieważ czasy updated_at nie są dla mnie przydatne do testowania, działa to dobrze.

data = { updated_at: Date.new(2019, 1, 1,), some_other_keys: ...}

expect(data).to eq(
  {updated_at: data[:updated_at], some_other_keys: ...}
)