ruby - prender - encender pantalla iphone 5 sin boton

¿Cómo apago cosas en MiniTest?

Question

Dentro de mi prueba, quiero resaltar una respuesta enlatada para cualquier instancia de una clase.

Puede parecer algo como:

Book.stubs(:title).any_instance().returns("War and Peace")

Luego, cada vez que llamo a @book.title devuelve "Guerra y paz".

¿Hay una manera de hacer esto dentro de MiniTest? Si es así, ¿puedes darme un fragmento de código de ejemplo?

¿O necesito algo como mocha?

MiniTest admite Mocks pero las mocks son excesivas por lo que necesito.

Answer 1

No puedes hacer esto con Minitest. Sin embargo, puede apilar cualquier instancia particular:

book = Book.new
book.stub(:title, ''War and Peace'') do
assert_equal ''War and Peace'', book.title
end

Answer 2

Pensé que compartiría un ejemplo que construí sobre las respuestas aquí.

Necesitaba quitar un método al final de una larga cadena de métodos. Todo comenzó con una nueva instancia de un contenedor de API de PayPal. La llamada que necesitaba para stub era esencialmente:

paypal_api = PayPal::API.new
response = paypal_api.make_payment
response.entries[0].details.payment.amount

Creé una clase que se devolvía a sí misma a menos que el método fuera amount

paypal_api = Class.new.tap do |c|
def c.method_missing(method, *_)
method == :amount ? 1.25 : self
end
end

Luego lo apagué en PayPal::API :

PayPal::API.stub :new, paypal_api do
get ''/paypal_payment'', amount: 1.25
assert_equal 1.25, payments.last.amount
end

¿Podría hacer que esto funcione para más de un método haciendo un hash y devolviendo hash.key?(method) ? hash[method] : self hash.key?(method) ? hash[method] : self .

Answer 3

Si estás interesado en un simple stubbing sin una biblioteca burlona, ​​entonces es bastante fácil hacer esto en Ruby:

class Book
def avg_word_count_per_page
arr = word_counts_per_page
sum = arr.inject(0) { |s,n| s += n }
len = arr.size
sum.to_f / len
end
def word_counts_per_page
# ... perhaps this is super time-consuming ...
end
end
describe Book do
describe ''#avg_word_count_per_page'' do
it "returns the right thing" do
book = Book.new
# a stub is just a redefinition of the method, nothing more
def book.word_counts_per_page; [1, 3, 5, 4, 8]; end
book.avg_word_count_per_page.must_equal 4.2
end
end
end

Si quieres algo más complicado como aplastar todas las instancias de una clase, entonces también es bastante fácil de hacer, solo tienes que ser un poco creativo:

class Book
def self.find_all_short_and_unread
repo = BookRepository.new
repo.find_all_short_and_unread
end
end
describe Book do
describe ''.find_all_short_unread'' do
before do
# exploit Ruby''s constant lookup mechanism
# when BookRepository is referenced in Book.find_all_short_and_unread
# then this class will be used instead of the real BookRepository
Book.send(:const_set, BookRepository, fake_book_repository_class)
end
after do
# clean up after ourselves so future tests will not be affected
Book.send(:remove_const, :BookRepository)
end
let(:fake_book_repository_class) do
Class.new(BookRepository)
end
it "returns the right thing" do
# Stub #initialize instead of .new so we have access to the
# BookRepository instance
fake_book_repository_class.send(:define_method, :initialize) do
super
def self.find_all_short_and_unread; [:book1, :book2]; end
end
Book.find_all_short_and_unread.must_equal [:book1, :book2]
end
end
end

Answer 4

Siempre puede crear un módulo en su código de prueba, y usar incluir o extender a las clases u objetos de mono-parche con él. por ejemplo (en book_test.rb)

module BookStub
def title
"War and Peace"
end
end

Ahora puedes usarlo en tus pruebas.

describe ''Book'' do
#change title for all books
before do
Book.include BookStub
end
end
#or use it in an individual instance
it ''must be War and Peace'' do
b=Book.new
b.extend BookStub
b.title.must_equal ''War and Peace''
end

Esto le permite armar comportamientos más complejos de lo que un simple código auxiliar podría permitir

Answer 5

Solo para explicar con más detalle la respuesta de @pánico , supongamos que tienes una clase de Libro:

require ''minitest/mock''
class Book; end

Primero, cree un talón de instancia de Libro y haga que devuelva el título deseado (cualquier número de veces):

book_instance_stub = Minitest::Mock.new
def book_instance_stub.title
desired_title = ''War and Peace''
return_value = desired_title
return_value
end

Luego, haga que la clase Book ejemplifique su código auxiliar de instancia de Book (solo y siempre, dentro del siguiente bloque de código):

return_value = book_instance_stub
method_to_redefine = :new
Book.stub method_to_redefine, return_value do
...

Dentro de este bloque de código (solo), el método Book :: new se apaga. Vamos a intentarlo:

 ...
some_book = Book.new
another_book = Book.new
puts some_book.title #=> "War and Peace"
puts some_book.title #=> "War and Peace"
end

O, muy tersamente:

require ''minitest/mock''
class Book; end
instance = Minitest::Mock.new
def instance.title() ''War and Peace'' end
Book.stub :new, instance do
book = Book.new
another_book = Book.new
puts book.title #=> "War and Peace"
puts book.title #=> "War and Peace"
end

Alternativamente, puede instalar la gema de la extensión Minitest ''minitest-stub_any_instance''. (Nota: utilizando este enfoque, el método del título del libro debe existir antes de que lo apague). Ahora, puede decir más simplemente:

require ''minitest/stub_any_instance''
class Book; def title() end end
desired_title = ''War and Peace''
Book.stub_any_instance :title, desired_title do
book = Book.new
another_book = Book.new
puts book.title #=> "War and Peace"
puts book.title #=> "War and Peace"
end

Si desea verificar que el título de Libro # se invoca un cierto número de veces, entonces haga lo siguiente:

require ''minitest/mock''
class Book; end
desired_title = ''War and Peace''
return_value = desired_title
method = :title
book_instance_stub = Minitest::Mock.new
number_of_title_invocations = 2
number_of_title_invocations.times do
book_instance_stub.expect method, return_value
end
return_value = book_instance_stub
method_to_redefine = :new
Book.stub method_to_redefine, return_value do
some_book = Book.new
puts some_book.title #=> "War and Peace"
puts some_book.title #=> "War and Peace"
end
book_instance_stub.verify

Por lo tanto, para cualquier instancia en particular, invocar el método MockExpectationError: No more expects available más veces que las especificadas aumenta MockExpectationError: No more expects available .

Además, para cualquier instancia en particular, invocar el método MockExpectationError: expected title() menos veces de lo especificado genera MockExpectationError: expected title() , pero solo si invoca #verify después en esa instancia.

Answer 6

Usted puede fácilmente MiniTest métodos en MiniTest . La información está disponible en github .

Entonces, siguiendo tu ejemplo y usando el estilo Minitest::Spec , esta es la forma en que deberías aplastar los métodos:

# - RSpec -
Book.stubs(:title).any_instance.returns("War and Peace")
# - MiniTest - #
Book.stub :title, "War and Peace" do
book = Book.new
book.title.must_equal "War and Peace"
end

Este es un ejemplo realmente estúpido, pero al menos te da una pista sobre cómo hacer lo que quieres hacer. Intenté esto usando MiniTest v2.5.1, que es la versión incluida que viene con Ruby 1.9 y parece que en esta versión el método #stub aún no era compatible, pero luego lo intenté con MiniTest v3.0 y funcionó a la perfección .

¡Buena suerte y felicitaciones por usar MiniTest !

Edit: También hay otro enfoque para esto, y aunque parece un poco pirateado, sigue siendo una solución a tu problema:

klass = Class.new Book do
define_method(:title) { "War and Peace" }
end
klass.new.title.must_equal "War and Peace"

Answer 7

Utilizo minitest para todas mis pruebas de gemas, pero hago todos mis talones con mocha, podría ser posible hacerlo todo en minitest con simulacros (no hay talones ni nada más, pero los simulacros son bastante poderosos), pero creo que mocha hace Gran trabajo, si ayuda:

require ''mocha''
Books.any_instance.stubs(:title).returns("War and Peace")

Answer 8

 book = MiniTest::Mock.new
book.expect :title, "War and Piece"
Book.stub :new, book do
wp = Book.new
wp.title # => "War and Piece"
end