ruby - mediante - spring mvc 4 tutorial español

Reiniciando una instancia de singleton en Ruby

Question

¿Cómo reinicio un objeto singleton en Ruby? Sé que uno nunca querría hacer esto en código real , pero ¿qué pasa con las pruebas unitarias?

Esto es lo que estoy tratando de hacer en una prueba de RSpec:

describe MySingleton, "#not_initialised" do
  it "raises an exception" do
    expect {MySingleton.get_something}.to raise_error(RuntimeError)
  end
end

Falla porque una de mis pruebas anteriores inicializa el objeto singleton. He intentado seguir los consejos de Ian White en this enlace, que esencialmente parlan parches Singleton para proporcionar un método reset_instance pero obtengo una excepción de método indefinido ''reset_instance''.

require ''singleton''

class <<Singleton
  def included_with_reset(klass)
    included_without_reset(klass)
    class <<klass
      def reset_instance
        Singleton.send :__init__, self
        self
      end
    end
  end
  alias_method :included_without_reset, :included
  alias_method :included, :included_with_reset
end

describe MySingleton, "#not_initialised" do
  it "raises an exception" do
    MySingleton.reset_instance
    expect {MySingleton.get_something}.to raise_error(RuntimeError)
  end
end

¿Cuál es la forma más idiomática de hacer esto en Ruby?

Answer 1

Para extraer un TL; DR de la agradable respuesta más larga anterior, para futuros visitantes perezosos como yo, encontré que esto es limpio y fácil:

Si tuvieras esto antes

let(:thing) { MyClass.instance }

Haz esto en lugar

let(:thing) { MyClass.clone.instance }

Answer 2

Pregunta difícil, los singletons son ásperos. En parte por la razón que está mostrando (cómo restablecerlo), y en parte porque hacen suposiciones que tienden a morderlo más tarde (por ejemplo, la mayoría de los rieles).

Hay un par de cosas que puedes hacer, todas están "bien" en el mejor de los casos. La mejor solución es encontrar una manera de deshacerse de singletons. Esto es mano-ondulada, lo sé, porque no hay una fórmula o un algoritmo que puedas aplicar, y elimina mucha conveniencia, pero si puedes hacerlo, a menudo vale la pena.

Si no puede hacerlo, al menos intente inyectar el singleton en lugar de acceder a él directamente. Las pruebas pueden ser difíciles en este momento, pero imagina tener que lidiar con problemas como este en el tiempo de ejecución. Para eso, necesitarías infraestructura incorporada para manejarlo.

Aquí hay seis enfoques que he pensado.

Proporcione una instancia de la clase, pero permita que se cree una instancia de la clase . Esto es lo más en línea con la forma en que tradicionalmente se presentan los singletons. Básicamente, en cualquier momento en que quiera referirse al singleton, hable con la instancia de singleton, pero puede probar contra otros casos. Hay un módulo en stdlib para ayudar con esto, pero hace que .new sea ​​privado, así que si quieres usarlo, deberías usar algo como let(:config) { Configuration.send :new } para probarlo.

class Configuration
  def self.instance
    @instance ||= new
  end

  attr_writer :credentials_file

  def credentials_file
    @credentials_file || raise("credentials file not set")
  end
end

describe Config do
  let(:config) { Configuration.new }

  specify ''.instance always refers to the same instance'' do
    Configuration.instance.should be_a_kind_of Configuration
    Configuration.instance.should equal Configuration.instance
  end

  describe ''credentials_file'' do  
    specify ''it can be set/reset'' do
      config.credentials_file = ''abc''
      config.credentials_file.should == ''abc''
      config.credentials_file = ''def''
      config.credentials_file.should == ''def''
    end

    specify ''raises an error if accessed before being initialized'' do
      expect { config.credentials_file }.to raise_error ''credentials file not set''
    end
  end
end

Luego, en cualquier lugar donde quiera acceder, use Configuration.instance

Haciendo el singleton una instancia de alguna otra clase . Luego puede probar la otra clase de forma aislada, y no necesita probar su singleton explícitamente.

class Counter
  attr_accessor :count

  def initialize
    @count = 0
  end

  def count!
    @count += 1
  end
end

describe Counter do
  let(:counter) { Counter.new }
  it ''starts at zero'' do
    counter.count.should be_zero
  end

  it ''increments when counted'' do
    counter.count!
    counter.count.should == 1
  end
end

Luego en tu aplicación en algún lugar:

MyCounter = Counter.new

Puede asegurarse de nunca editar la clase principal, luego, haga una subclase para sus pruebas:

class Configuration
  class << self
    attr_writer :credentials_file
  end

  def self.credentials_file
    @credentials_file || raise("credentials file not set")
  end
end

describe Config do
  let(:config) { Class.new Configuration }
  describe ''credentials_file'' do  
    specify ''it can be set/reset'' do
      config.credentials_file = ''abc''
      config.credentials_file.should == ''abc''
      config.credentials_file = ''def''
      config.credentials_file.should == ''def''
    end

    specify ''raises an error if accessed before being initialized'' do
      expect { config.credentials_file }.to raise_error ''credentials file not set''
    end
  end
end

Luego en tu aplicación en algún lugar:

MyConfig = Class.new Configuration

Asegúrese de que hay una manera de restablecer el singleton . O más generalmente, deshacer cualquier cosa que hagas. (p. ej., si puede registrar algún objeto con el singleton, entonces debe poder anular el registro, en Rails, por ejemplo, cuando subclase Railtie , lo registra en una matriz, pero puede acceder a la matriz y eliminar el elemento). de ella ).

class Configuration
  def self.reset
    @credentials_file = nil
  end

  class << self
    attr_writer :credentials_file
  end

  def self.credentials_file
    @credentials_file || raise("credentials file not set")
  end
end

RSpec.configure do |config|
  config.before { Configuration.reset }
end

describe Config do
  describe ''credentials_file'' do  
    specify ''it can be set/reset'' do
      Configuration.credentials_file = ''abc''
      Configuration.credentials_file.should == ''abc''
      Configuration.credentials_file = ''def''
      Configuration.credentials_file.should == ''def''
    end

    specify ''raises an error if accessed before being initialized'' do
      expect { Configuration.credentials_file }.to raise_error ''credentials file not set''
    end
  end
end

Clona la clase en lugar de probarlo directamente. Esto surgió de una gist que hice, básicamente, editas el clon en lugar de la clase real.

class Configuration  
  class << self
    attr_writer :credentials_file
  end

  def self.credentials_file
    @credentials_file || raise("credentials file not set")
  end
end

describe Config do
  let(:configuration) { Configuration.clone }

  describe ''credentials_file'' do  
    specify ''it can be set/reset'' do
      configuration.credentials_file = ''abc''
      configuration.credentials_file.should == ''abc''
      configuration.credentials_file = ''def''
      configuration.credentials_file.should == ''def''
    end

    specify ''raises an error if accessed before being initialized'' do
      expect { configuration.credentials_file }.to raise_error ''credentials file not set''
    end
  end
end

Desarrolle el comportamiento en módulos , luego extiéndalo sobre singleton. Here hay un ejemplo un poco más complicado. Probablemente tendrías que buscar en los métodos self.extended self.included y self.extended si necesitas inicializar algunas variables en el objeto.

module ConfigurationBehaviour
  attr_writer :credentials_file
  def credentials_file
    @credentials_file || raise("credentials file not set")
  end
end

describe Config do
  let(:configuration) { Class.new { extend ConfigurationBehaviour } }

  describe ''credentials_file'' do  
    specify ''it can be set/reset'' do
      configuration.credentials_file = ''abc''
      configuration.credentials_file.should == ''abc''
      configuration.credentials_file = ''def''
      configuration.credentials_file.should == ''def''
    end

    specify ''raises an error if accessed before being initialized'' do
      expect { configuration.credentials_file }.to raise_error ''credentials file not set''
    end
  end
end

Luego en tu aplicación en algún lugar:

class Configuration  
  extend ConfigurationBehaviour
end

Answer 3

Supongo que simplemente hacer esto solucionará tu problema:

describe MySingleton, "#not_initialised" do
  it "raises an exception" do
    Singleton.__init__(MySingleton)
    expect {MySingleton.get_something}.to raise_error(RuntimeError)
  end
end

o incluso mejor agregar antes de devolución de llamada:

describe MySingleton, "#not_initialised" do
  before(:each) { Singleton.__init__(MySingleton) }
end