Fügen Sie Tests für dependent: destroy im Beziehungsmodell hinzu (Kapitel 11, Übung 1 Rails Tutorial, 2. Ausgabe)

Question

Ziemlich sicher, dass diese Tests ordnungsgemäß funktionieren. Haben Sie einen Fehler, indem Sie die abhängigen Optionen: destroy in has_many: relationshases und has_many: reverse_relationships in user.rb entfernen.

gesucht, was ich sonst durch Michael Hartl's Rails Tutorial 2nd Edition, Chapter 11 Exercises.

Einige Fragen aus dieser Übung entstanden funktioniert hat, falls jemand zu teilen (Ende der Post sehen). Wenn jemand helfen könnte, wäre das großartig.

Kapitel 11, Übung 1:

Tests hinzu abhängig: zerstören im Modell Relationship (Listing 11.4 und Listing 11.16) durch das Beispiel folgende 10,15 in Listing.

Hier ist mein Test: spec/models/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 

---

Ein paar Fragen aus dieser Übung entstanden:

Frage 1:

Meine erste Tests waren Beziehungen.shou ld be_nil reverse_relationships.should be_nil

Aber realisiert, ein Array wurde immer noch zurückgegeben, obwohl kein Benutzer existiert. Wenn also ein Benutzer nicht existiert und eine Assoziationsmethode aufgerufen wird, ist das Ergebnis immer noch ein Array? Ist das immer wahr?

Frage 2:

ich mit Löschen von Beziehungen und reverse_relationships für einen Benutzer in der Schienen-Konsole spielen, um wollte.

Ich habe versucht, diese

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

Wie dauerhaft ich zerstören tatsächlich die Beziehungen? Scheint gut zu wissen, wenn man in der Konsole forscht.

Danke! Ich bin immer noch ziemlich neu in Rails

Answer 1

Ich bin ein Rubin/Rails Noob auch.

Frage 1: Gesucht rubyonrails.org für has_many und es sagt

Gibt ein Array aller zugehörigen Objekte. Ein leeres Array wird zurückgegeben, wenn keines gefunden wird.

Auf einer seitlichen Anmerkung, können Sie testen, beide null und leer:

relationships.present?.should be_false 

Frage 2: Die user.relationships.destroy erfordert ein: id

user.relationships.destroy '1' 

Answer 2

Vielen Dank für Ihren Code veröffentlichen Ihre Frage. Ich wollte das nur als Kommentar und nicht als Antwort schreiben, aber es scheint, ich kann es noch nicht. Wie auch immer, ich wollte nur einen kleinen potenziellen Kandidaten zu Ihren Tests hinzufügen, aber aus der Perspektive der other_user. Der Test ist ähnlich zu den Follow/Unfold-Tests, so hoffentlich wäre es nicht zu redundant, aber es testet relationships direkt und nicht die followed_users und followers, die durch sie gehen.

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.

Übung 11.5.1 Tests hinzufügen für Beziehungen im Zusammenhang mit einem bestimmten Benutzer zu zerstören.

Dieser Code funktioniert für mich. Ich habe versucht, dem Beispiel Listing 10.15 zu folgen.

spec/models/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, wird die Beziehungen Array nicht von den Benutzern gebildet wird, so sein() enthalten immer falsch sein sollte, so dass der Test immer grün. Re: Maria, es scheint, dass die Methoden "folged_users" und "followers" keinen Benutzer zurückgeben, der nicht existiert, selbst wenn eine Beziehung, die auf sie verweist, bestehen bleibt. Also ist dieser Test auch nie rot.

eine andere Lösung:

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

Die oben genannten Antworten arbeiten, aber ich denke, ich würde mein teile es kürzer ist ..: 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 können Sie auslassen:

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

aber ich werfe es dort für jemanden, der sicherstellen will, dass alle damit verbundenen Zerstörungsaktion bei der Arbeit ist.

Answer 6

können Sie benötigen smt ähnliche

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