Problème de comparaison du temps avec RSpec

J'utilise Ruby on Rails 4 et le gem 2.14 rspec-rails. Pour mon objet, je voudrais comparer l'heure actuelle avec l' updated_atattribut d'objet après l'exécution d'une action du contrôleur, mais je suis en difficulté car la spécification ne passe pas. Autrement dit, étant donné ce qui suit est le code de spécification:

it "updates updated_at attribute" do
  Timecop.freeze

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

Lorsque j'exécute les spécifications ci-dessus, j'obtiens l'erreur suivante:

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 ==)

Comment puis-je faire passer les spécifications?

Remarque : j'ai également essayé ce qui suit (notez l' utcajout):

it "updates updated_at attribute" do
  Timecop.freeze

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

mais la spécification ne passe toujours pas (notez la différence de valeur "obtenue"):

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 ==)

L'objet Ruby Time maintient une plus grande précision que la base de données. Lorsque la valeur est lue à partir de la base de données, elle n'est conservée qu'à la microseconde, tandis que la représentation en mémoire est précise en nanosecondes.

Si vous ne vous souciez pas de la différence en millisecondes, vous pouvez faire un to_s / to_i des deux côtés de votre attente

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

ou

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

Reportez-vous à ceci pour plus d'informations sur les raisons pour lesquelles les heures sont différentes

Je trouve que l'utilisation du be_withinmatcher rspec par défaut est plus élégante:

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

oui, car cela Oinsuggère que le be_withinmatcher est la meilleure pratique

... et il a quelques autres cas d'utilisation -> http://www.eq8.eu/blogs/27-rspec-be_within-matcher

Mais une autre façon de gérer cela est d'utiliser les Rails intégrés middayet les middnightattributs.

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

Maintenant, c'est juste pour la démonstration!

Je n'utiliserais pas cela dans un contrôleur car vous stubbing tous les appels Time.new => tous les attributs de temps auront le même temps => peuvent ne pas prouver le concept que vous essayez d'atteindre. Je l'utilise généralement dans des objets Ruby composés similaires à ceci:

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

Mais honnêtement, je recommande de rester avec be_withinmatcher même lorsque vous comparez Time.now.midday!

Alors oui, veuillez coller avec le be_withinmatcher;)

mise à jour 2017-02

Question en commentaire:

et si les temps sont dans un hachage? n'importe quel moyen de faire en sorte que expect (hash_1) .to eq (hash_2) fonctionne quand certaines valeurs de hash_1 sont pré-db-times et les valeurs correspondantes dans hash_2 sont post-db-times? -

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

vous pouvez passer n'importe quel matcher RSpec au matchmatcher (vous pouvez donc même faire des tests API avec RSpec pur )

En ce qui concerne "post-db-times", je suppose que vous voulez dire une chaîne qui est générée après l'enregistrement dans DB. Je suggérerais de découpler ce cas en 2 attentes (une assurant la structure de hachage, une deuxième vérification de l'heure) Vous pouvez donc faire quelque chose comme:

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)

Mais si ce cas est trop souvent dans votre suite de tests, je suggérerais d'écrire votre propre matcher RSpec (par exemple be_near_time_now_db_string) en convertissant le temps de la chaîne db en objet Time, puis de l'utiliser dans le cadre de match(hash):

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

Ancien message, mais j'espère que cela aidera quiconque entre ici pour une solution. Je pense qu'il est plus facile et plus fiable de simplement créer la date manuellement:

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

Cela garantit que la date stockée est la bonne, sans faire to_xni se soucier des décimales.

Vous pouvez convertir l'objet date / datetime / time en une chaîne tel qu'il est stocké dans la base de données avec 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)

Le moyen le plus simple que j'ai trouvé autour de ce problème est de créer une current_timeméthode d'assistance de test comme ceci:

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

Désormais, l'heure est toujours arrondie à la milliseconde la plus proche pour que les comparaisons soient simples:

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

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

Parce que je comparais les hachages, la plupart de ces solutions ne fonctionnaient pas pour moi, alors j'ai trouvé que la solution la plus simple était simplement de récupérer les données du hachage que je comparais. Étant donné que les heures de mise à jour ne sont pas vraiment utiles pour moi, cela fonctionne correctement.

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

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