Agregar pruebas para dependiente: destruir en el modelo de relación (Capítulo 11, Ejercicio 1, Tutorial de rieles, 2da edición)

Question

Bastante seguro de que estas pruebas funcionan correctamente. Conseguí que fallaran al eliminar el dependiente:: opciones de destrucción en has_many: relaciones y has_many: reverse_relationships en user.rb.

quería compartir lo que he hecho en cualquier caso más está trabajando a través de Michael Hartl's Rails Tutorial 2nd Edition, Chapter 11 Exercises.

Algunas preguntas surgieron de este ejercicio (véase la parte inferior de este post). Si alguien pudiera ayudar, sería genial.

Capítulo 11, Ejercicio 1:

añadir pruebas para dependientes: destruir en el modelo de relación (Listado 11,4 y el listado 11.16), siguiendo el ejemplo del Listado 10.15.

Aquí está mi prueba: especificación/modelos/user_spec.rb

require 'spec_helper' 

describe User do 

    before do 
    @user = User.new(name: "Example User", email: "user@example.com", 
        password: "foobar", password_confirmation: "foobar") 
    end 

    subject { @user } 

    [...code omitted...] 

    describe "relationship associations" do 
    let(:other_user) { FactoryGirl.create(:user) } 
    before do 
     @user.save 
     @user.follow!(other_user) 
     other_user.follow!(@user) 
    end 

    it "should destroy associated relationships" do 
     relationships = @user.relationships 
     @user.destroy 
     relationships.should be_empty 
    end 

    it "should destroy associated reverse relationships" do 
     reverse_relationships = @user.reverse_relationships 
     @user.destroy 
     reverse_relationships.should be_empty 
    end 
    end 

---

un par de preguntas surgieron de este ejercicio:

Pregunta 1:

Mi las pruebas iniciales fueron relationships.shou ld be_nil reverse_relationships.should be_nil

Pero, se dio cuenta de que todavía se estaba devolviendo una matriz, a pesar de que no existía ningún usuario. Entonces, cuando un usuario no existe y se llama a un método de asociación, ¿el resultado sigue siendo una matriz? Es esto siempre cierto?

Pregunta 2:

quería jugar un poco con la supresión de las relaciones y reverse_relationships para un usuario en la consola de rieles.

yo probamos este

> user = User.first 
> user.relationships 
# returns a bunch of relationships 
> user.relationships.destroy 
=> [] 
> user.relationships 
# returns same bunch of relationships 

¿Cómo realmente destruir las relaciones de forma permanente? Parece algo bueno saber al explorar en la consola.

Gracias! Todavía soy bastante nuevo en Rails

Answer 1

Soy un novato de ruby ​​/ rails también.

Pregunta 1: Buscado rubyonrails.org para has_many y dice

Devuelve una matriz de todos los objetos asociados. Se devuelve una matriz vacía si no se encuentra ninguna.

En una nota lateral, puede probar tanto nulo y vacío:

relationships.present?.should be_false 

Pregunta 2: El user.relationships.destroy requiere una: Identificación del

user.relationships.destroy '1' 

Answer 2

Gracias por publicar un código con tu pregunta. Solo quería publicar esto como un comentario y no como una respuesta, pero parece que todavía no puedo. De todos modos, solo quería agregar un pequeño candidato potencial para sus pruebas, pero desde la perspectiva other_user. La prueba es similar a las pruebas follow/unfollow, así que con suerte no sería demasiado redundante, pero prueba relationships directamente y no el followed_users y followers que pasan por ellos.

describe "relationship associations" do 
    ... 
    context "when a follower/followed user is destroyed" do 
    subject { other_user } 

    before { user.destroy } 

    its(:relationships) { should_not include(user) } 
    its(:reverse_relationships) { should_not include(user) } 
    end 
end 

Answer 3

Ruby on Rails Tutorial 2nd Edition.

Ejercicio 11.5.1 añadir pruebas para la destrucción de las relaciones asociadas con un usuario determinado.

Este código funciona para mí. Intenté seguir el ejemplo Listing 10.15.

spec/modelos/user_spec.rb

require 'spec_helper' 

describe User do 

    before do 
    @user = User.new(name: "Example User", email: "user@example.com", password: "foobar", password_confirmation: "foobar") 
    end 

    subject { @user } 
    . 
    . 
    . 
    . 
    describe "user relationships associations" do 
    let (:other_user) { FactoryGirl.create(:user) } 
    let (:another_user) { FactoryGirl.create(:user) } 

    before do 
     @user.save 
     @user.follow!(other_user) 
     @user.follow!(another_user) 
     other_user.follow!(@user) 
     other_user.follow!(another_user) 
     another_user.follow!(@user) 
     another_user.follow!(other_user) 
    end 

    its(:followed_users) { should include(other_user) } 
    its(:followers) { should include(another_user) } 

    it "should destroy associated followers" do 
     followers = @user.followers 
     @user.destroy 
     followers.each do |follower| 
     follower.followed_users.should_not include(@user) 
     end 
    end 

    it "should destroy associated followed users" do 
     followed_users = @user.followed_users 
     @user.destroy 
     followed_users.each do |followed_user| 
     followed_user.followers.should_not include(@user) 
     end 
    end 
    end 
end 

Answer 4

Re: paul, la matriz de relaciones no está constituida por los usuarios, por lo que su include() siempre debe ser falsa, por lo que la prueba siempre verde. Re: maria, parece que los métodos seguidores_usuarios y seguidores no devolverán a un usuario que no existe, incluso si permanece una relación que hace referencia a él o ella. Entonces esta prueba nunca es roja también

otra solución:

describe "relationships" do 
    let(:other_user) { FactoryGirl.create(:user) } 
    before do 
     @user.save 
     @user.follow!(other_user) 
    end 

    let(:relationship) { @user.relationships.last } 

    describe "should be destroyed when the followed user is destroyed" do 
     before { other_user.destroy } 
     its(:relationships) { should_not include(relationship) } 
    end 

    describe "should be destroyed when the following user is destroyed" do 
     subject { other_user } 
     before { @user.destroy } 
     its(:reverse_relationships) { should_not include(relationship) } 
    end 
    end 

Answer 5

Las respuestas anteriores funcionan, pero calculo que iba a compartir la mía es más corto ..: D

describe "following" do 

    let(:other_user) { FactoryGirl.create(:user) } 
    before do 
    @user.save 
    @user.follow!(other_user) 
    other_user.follow!(@user) 
    end 

    it { should be_following(other_user) } 
    its(:followed_users) { should include(other_user) } 

    it "should destroy associated followed_users and followers" do 
    @user.destroy 
    @user.relationships.present?.should be_false 
    @user.reverse_relationships.present?.should be_false 

    expect(other_user.followers).not_to include(@user) 
    expect(other_user.followed_users).not_to include(@user) 
    end 
    . 
    . 
    . 
    . 
end 
end 

PS se puede dejar de lado:

@user.relationships.present?.should be_false 
@user.reverse_relationships.present?.should be_false 

pero lo tiro allí para alguien que quiere asegurarse de que todas las acciones de destrucción asociadas estén en funcionamiento.

Answer 6

puede ser que necesite SMT como éste

it { should have_many(:relationships).dependent(:destroy) }