interest 0.0.1

data/spec/database.yml.example

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: spec/database.sqlite3

data/spec/follow_requestable_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+describe "FollowRequestable" do
+  it "should follow request" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    user.request_to_follow(other_user)
+
+    expect(user).to have_requested_to_follow(other_user)
+    expect(other_user).to have_been_requested_to_follow(user)
+  end
+
+  it "should not duplicate follow request" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    user.request_to_follow(other_user)
+    user.request_to_follow(other_user)
+
+    expect(user.outgoing_follow_requests.count).to eq(1)
+    expect(user.follow_requestee_follow_requestable_users.count).to eq(1)
+  end
+
+  it "should be a Following" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    user.request_to_follow(other_user)
+
+    expect(user.outgoing_follow_requests.of(FollowRequestableUser)).to be_present.and all be_a Following
+  end
+
+  it "should be a model is requested to follow" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+    collection = Collection.create!
+
+    user.request_to_follow(other_user)
+    user.request_to_follow(collection)
+
+    expect(user.follow_requestee_follow_requestable_users).to be_present.and all be_a FollowRequestableUser
+  end
+
+  it "should cancel follow request" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    user.request_to_follow(other_user)
+    user.cancel_request_to_follow(other_user)
+
+    expect(user).not_to have_requested_to_follow(other_user)
+    expect(other_user).not_to have_been_requested_to_follow(user)
+  end
+
+  it "should not follow request self" do
+    user = FollowRequestableUser.create!
+
+    user.request_to_follow(user)
+
+    expect(user).not_to have_been_requested_to_follow(user)
+  end
+
+  it "should not follow request self and raise exception" do
+    user = FollowRequestableUser.create!
+
+    expect { user.request_to_follow!(user) }.to raise_error(Interest::FollowRequestable::Rejected)
+  end
+
+  it "should not follow request if already following" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    user.follow(other_user)
+
+    expect { user.request_to_follow!(other_user) }.to raise_error(Interest::FollowRequestable::Rejected)
+  end
+
+  it "should not follow request if blocked" do
+    user       = FollowRequestableAndBlockableUser.create!
+    other_user = FollowRequestableAndBlockableUser.create!
+
+    other_user.block(user)
+
+    expect { user.request_to_follow!(other_user) }.to raise_error(Interest::FollowRequestable::Rejected)
+  end
+
+  it "should follow or request to follow" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    allow(user).to receive(:requires_request_to_follow?).and_return(true)
+    allow(other_user).to receive(:requires_request_to_follow?).and_return(false)
+
+    expect(user.follow_or_request_to_follow!(other_user).followed?).to eq(true)
+    expect(other_user.follow_or_request_to_follow!(user).requested_to_follow?).to eq(true)
+  end
+
+  it "should find outgoing follow request of specified type" do
+    user        = FollowRequestableUser.create!
+    other_user1 = FollowRequestableUser.create!
+    other_user2 = FollowRequestableUser.create!
+    collection  = Collection.create!
+
+    user.request_to_follow(other_user1)
+    user.request_to_follow(other_user2)
+    user.request_to_follow(collection)
+
+    expect(user.outgoing_follow_requests.of(FollowRequestableUser)).to have_exactly(2).items
+    expect(user.outgoing_follow_requests.of(Collection)).to have_exactly(1).items
+  end
+
+  it "should find incoming follow request of specified type" do
+    user        = FollowRequestableUser.create!
+    other_user1 = FollowRequestableUser.create!
+    other_user2 = FollowRequestableUser.create!
+    collection  = Collection.create!
+
+    other_user1.request_to_follow(user)
+    other_user2.request_to_follow(user)
+    collection.request_to_follow(user)
+
+    expect(user.incoming_follow_requests.of(FollowRequestableUser)).to have_exactly(2).items
+    expect(user.incoming_follow_requests.of(Collection)).to have_exactly(1).items
+  end
+end

data/spec/followable_spec.rb

@@ -0,0 +1,171 @@
+require "spec_helper"
+
+describe "Followable" do
+  it "should follow other" do
+    user       = FollowableUser.create!
+    other_user = FollowableUser.create!
+
+    user.follow(other_user)
+
+    expect(user).to be_following(other_user)
+  end
+
+  it "should not follow self and raise exception" do
+    user = FollowableUser.create!
+
+    expect { user.follow!(user) }.to raise_error(Interest::Followable::Rejected)
+  end
+
+  it "should not follow self" do
+    user = FollowableUser.create!
+
+    user.follow(user)
+
+    expect(user.following_followable_users).to be_empty
+  end
+
+  it "should not duplicate followee" do
+    user       = FollowableUser.create!
+    other_user = FollowableUser.create!
+
+    user.follow(other_user)
+    user.follow(other_user)
+
+    expect(user.following_relationships.count).to eq(1)
+    expect(user.following_followable_users.count).to eq(1)
+  end
+
+  it "should be a Following" do
+    user       = FollowableUser.create!
+    other_user = FollowableUser.create!
+
+    user.follow(other_user)
+
+    expect(user.following_relationships.of(FollowableUser)).to be_present.and all be_a Following
+  end
+
+  it "should be a model is followed" do
+    user       = FollowableUser.create!
+    other_user = FollowableUser.create!
+    stuff      = Stuff.create!
+
+    user.follow(other_user)
+    user.follow(stuff)
+
+    expect(user.following_followable_users).to be_present.and all be_a FollowableUser
+  end
+
+  it "should follow several types" do
+    user       = FollowableUser.create!
+    other_user = FollowableUser.create!
+    stuff      = Stuff.create!
+
+    user.follow(other_user)
+    user.follow(stuff)
+
+    expect(user).to be_following(other_user)
+    expect(user).to be_following(stuff)
+  end
+
+  it "should unfollow" do
+    user       = FollowableUser.create!
+    other_user = FollowableUser.create!
+
+    user.follow(other_user)
+    user.unfollow(other_user)
+
+    expect(user).not_to be_following(other_user)
+  end
+
+  it "should determine if self is followed by other" do
+    user             = FollowableUser.create!
+    other_user       = FollowableUser.create!
+    indifferent_user = FollowableUser.create!
+
+    other_user.follow(user)
+
+    expect(user).to be_followed_by(other_user)
+    expect(user).not_to be_followed_by(indifferent_user)
+  end
+
+  context "following several types" do
+    let(:user) { FollowableUser.create! }
+    let(:popular_user) { FollowableUser.create! }
+
+    before do
+      other_user = FollowableUser.create!
+      stuff      = Stuff.create!
+      collection = Collection.create!
+
+      user.following_relationships.destroy_all
+      popular_user.follower_relationships.destroy_all
+
+      user.follow(other_user)
+      user.follow(stuff)
+      user.follow(collection)
+      user.follow(popular_user)
+      other_user.follow(popular_user)
+      collection.follow(popular_user)
+    end
+
+    it "should count following" do
+      expect(user.following_relationships.count).to eq(4)
+    end
+
+    it "should count each type of followings" do
+      expect(user.following_followable_users.count).to eq(2)
+      expect(user.following_stuffs.count).to eq(1)
+      expect(user.following_collections.count).to eq(1)
+    end
+
+    it "should count followers" do
+      expect(popular_user.follower_relationships.count).to eq(3)
+    end
+
+    it "should count each type of followers" do
+      expect(popular_user.follower_followable_users.count).to eq(2)
+      expect(popular_user.follower_collections.count).to eq(1)
+    end
+  end
+
+  it "should destroy their follow requests when either requester or requestee follows other" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    user.request_to_follow(other_user)
+    other_user.request_to_follow(user)
+
+    user.follow(other_user)
+
+    expect(user).not_to have_requested_to_follow(other_user)
+    expect(other_user).not_to have_been_requested_to_follow(user)
+  end
+
+  it "should find outgoing following of specified type" do
+    user        = FollowableUser.create!
+    other_user1 = FollowableUser.create!
+    other_user2 = FollowableUser.create!
+    collection  = Collection.create!
+
+    user.follow(other_user1)
+    user.follow(other_user2)
+    user.follow(collection)
+
+    expect(user.following_relationships.of(FollowableUser)).to have_exactly(2).items
+    expect(user.following_relationships.of(Collection)).to have_exactly(1).items
+  end
+
+  it "should find incoming following of specified type" do
+    user        = FollowableUser.create!
+    other_user1 = FollowableUser.create!
+    other_user2 = FollowableUser.create!
+    collection  = Collection.create!
+
+    other_user1.follow(user)
+    other_user2.follow(user)
+    collection.follow(user)
+
+    expect(user.follower_relationships.of(FollowableUser)).to have_exactly(2).items
+    expect(user.follower_relationships.of(Collection)).to have_exactly(1).items
+  end
+end

data/spec/models/blocking_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Blocking do
+  it "should be invalid if blocker and blockee are not set" do
+    expect { Blocking.create! }.to raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  it "should be invalid" do
+    user       = BlockableUser.create!
+    other_user = FollowableUser.create!
+
+    expect { Blocking.create! blocker: user, blockee: other_user }.to raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  it "should destroy relationships between a and b" do
+    a = BlockableUser.create!
+    b = BlockableUser.create!
+
+    a.block(b)
+    b.block(a)
+
+    Blocking.destroy_relationships_between(a, b)
+
+    expect(Blocking.between(a, b)).to have_exactly(0).items
+  end
+
+  describe "between scope" do
+    let(:a) { BlockableUser.create! }
+    let(:b) { BlockableUser.create! }
+
+    before do
+      Blocking.destroy_relationships_between(a, b)
+
+      a.block(b)
+      b.block(a)
+    end
+
+    it "should get relationships between a and b" do
+      expect(Blocking.between(a, b)).to have_exactly(2).items
+    end
+  end
+end

data/spec/models/following_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+describe Following do
+  it "should be invalid if follower and followee are not set" do
+    expect { Following.create! }.to raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  it "should be invalid" do
+    user       = FollowRequestableAndBlockableUser.create!
+    other_user = FollowRequestableAndBlockableUser.create!
+
+    other_user.block(user)
+
+    expect { Following.create! follower: user, followee: other_user, status: "pending" }.to raise_error(ActiveRecord::RecordInvalid)
+    expect { Following.create! follower: user, followee: other_user, status: "accepted" }.to raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  it "should let requester follow requestee when accepted request" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    user.request_to_follow(other_user).accept!
+
+    expect(user).to be_following(other_user)
+    expect(other_user).not_to be_following(user)
+  end
+
+  it "should change status when accepted request" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    follow_request = user.request_to_follow(other_user)
+    follow_request.accept!
+
+    expect(follow_request).to be_accepted
+  end
+
+  it "should destroy when rejected request" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    follow_request = user.request_to_follow(other_user)
+    follow_request.reject!
+
+    expect(follow_request).to be_destroyed
+  end
+
+  it "should accept to follow and follow each other" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    request = user.request_to_follow(other_user)
+    request.accept_mutual_follow!
+
+    expect(user).to be_following(other_user)
+    expect(other_user).to be_following(user)
+  end
+
+  it "should follow each other" do
+    user       = FollowRequestableUser.create!
+    other_user = FollowRequestableUser.create!
+
+    user.follow(other_user).mutual
+
+    expect(user).to be_following(other_user)
+    expect(other_user).to be_following(user)
+  end
+
+  it "should destroy relationships between a and b" do
+    a = FollowRequestableUser.create!
+    b = FollowRequestableUser.create!
+
+    a.follow(b).mutual
+
+    Following.destroy_relationships_between(a, b)
+
+    expect(Following.between(a, b)).to have_exactly(0).items
+  end
+
+  describe "accepted and pending scopes" do
+    before :all do
+      Following.destroy_all
+
+      2.times { FollowRequestableUser.create!.follow!(FollowRequestableUser.create!) }
+      2.times { FollowRequestableUser.create!.request_to_follow!(FollowRequestableUser.create!) }
+    end
+
+    it "should get all following" do
+      expect(Following.accepted).to be_present.and all be_accepted
+    end
+
+    it "should get all follow requests" do
+      expect(Following.pending).to be_present.and all be_pending
+    end
+  end
+
+  describe "between scope" do
+    let(:a) { FollowRequestableUser.create! }
+    let(:b) { FollowRequestableUser.create! }
+
+    before do
+      Following.destroy_relationships_between(a, b)
+
+      a.follow(b)
+      b.request_to_follow(a)
+    end
+
+    it "should get all relationships between a and b" do
+      expect(Following.between(a, b)).to have_exactly(2).items
+    end
+
+    it "should get accepted relationship" do
+      expect(Following.between(a, b).accepted).to have_exactly(1).items
+    end
+
+    it "should get pending relationship" do
+      expect(Following.between(a, b).pending).to have_exactly(1).items
+    end
+  end
+end