socializer 0.1.13

data/spec/models/socializer/comment_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Socializer
+  describe Comment do
+    let(:comment) { build(:socializer_comment) }
+
+    it 'has a valid factory' do
+      expect(comment).to be_valid
+    end
+
+    it '#content' do
+      expect(comment).to respond_to(:content)
+    end
+
+    it '#author' do
+      expect(comment).to respond_to(:author)
+    end
+  end
+end

data/spec/models/socializer/group_category_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Socializer
+  describe GroupCategory do
+    let(:group_category) { build(:socializer_group_category) }
+
+    it 'has a valid factory' do
+      expect(group_category).to be_valid
+    end
+
+    context 'mass assignment' do
+      it { expect(group_category).to allow_mass_assignment_of(:name) }
+    end
+
+    context 'relationships' do
+      it { expect(group_category).to belong_to(:group) }
+    end
+
+    context 'validations' do
+      it { expect(group_category).to validate_presence_of(:name) }
+    end
+  end
+end

data/spec/models/socializer/group_link_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Socializer
+  describe GroupLink do
+    let(:group_link) { build(:socializer_group_link) }
+
+    it 'has a valid factory' do
+      expect(group_link).to be_valid
+    end
+
+    context 'mass assignment' do
+      it { expect(group_link).to allow_mass_assignment_of(:label) }
+      it { expect(group_link).to allow_mass_assignment_of(:url) }
+    end
+
+    context 'relationships' do
+      it { expect(group_link).to belong_to(:group) }
+    end
+
+    context 'validations' do
+      it { expect(group_link).to validate_presence_of(:label) }
+      it { expect(group_link).to validate_presence_of(:url) }
+    end
+  end
+end

data/spec/models/socializer/group_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+
+module Socializer
+  describe Group do
+    let(:group) { build(:socializer_group) }
+
+    it 'has a valid factory' do
+      expect(group).to be_valid
+    end
+
+    context 'mass assignment' do
+      it { expect(group).to allow_mass_assignment_of(:name) }
+      it { expect(group).to allow_mass_assignment_of(:privacy_level) }
+      it { expect(group).to allow_mass_assignment_of(:author_id) }
+    end
+
+    context 'relationships' do
+      it { expect(group).to belong_to(:activity_author) }
+      it { expect(group).to have_many(:memberships) }
+      it { expect(group).to have_many(:activity_members).through(:memberships).conditions(socializer_memberships: { active: true }) }
+      it { expect(group).to have_many(:links) }
+      it { expect(group).to have_many(:categories) }
+    end
+
+    context 'validations' do
+      # TODO: Update factory to include relationshp
+      # it { expect(group).to validate_presence_of(:activity_author) }
+      it { expect(group).to validate_presence_of(:author_id) }
+      it { expect(group).to validate_presence_of(:name) }
+      it { expect(group).to validate_presence_of(:privacy_level) }
+      it { expect(create(:socializer_group)).to validate_uniqueness_of(:name).scoped_to(:author_id) }
+    end
+
+    it { expect(enumerize(:privacy_level).in(:public, :restricted, :private).with_default(:public)) }
+
+    it '#author' do
+      expect(group).to respond_to(:author)
+    end
+
+    it '#members' do
+      expect(group).to respond_to(:members)
+    end
+
+    it '#join' do
+      expect(group).to respond_to(:join)
+    end
+
+    it '#invite' do
+      expect(group).to respond_to(:invite)
+    end
+
+    it '#leave' do
+      expect(group).to respond_to(:leave)
+    end
+
+    it '#member?' do
+      expect(group).to respond_to(:member?)
+    end
+
+    context 'when group is public' do
+      let(:public_group) { create(:socializer_group, privacy_level: 1) }
+      let(:person) { create(:socializer_person) }
+
+      before do
+        public_group.save!
+      end
+
+      it '.public has 1 group' do
+        expect(Socializer::Group.public.size).to eq(1)
+      end
+
+      it '.joinable has 1 group' do
+        expect(Socializer::Group.joinable.size).to eq(1)
+      end
+
+      it 'is has the right privacy level' do
+        expect(public_group.privacy_level.public?).to be_true
+      end
+
+      it 'member? is false' do
+        expect(public_group.member?(person)).to be_false
+      end
+
+      context 'and a person joins it' do
+        before do
+          public_group.join(person)
+          @membership = Membership.find_by(member_id: person.guid, group_id: public_group.id)
+        end
+
+        it 'creates an active membership' do
+          expect(@membership.active).to be_true
+        end
+
+        it 'member? is true' do
+          expect(public_group.member?(person)).to be_true
+        end
+
+        it 'has 1 member' do
+          expect(public_group.members.size).to eq(1)
+        end
+
+        context 'and leaving' do
+          before do
+            public_group.leave(person)
+            @membership = Membership.find_by(member_id: person.guid, group_id: public_group.id)
+          end
+
+          it 'destroys the membership' do
+            expect(@membership).to be_nil
+          end
+
+          it 'has 0 member' do
+          expect(public_group.members.size).to eq(0)
+        end
+        end
+      end
+    end
+
+    context 'when group is restricted' do
+      let(:restricted_group) { create(:socializer_group, privacy_level: 2) }
+      let(:person) { create(:socializer_person) }
+
+      before do
+        restricted_group.save!
+      end
+
+      it '.restricted has 1 group' do
+        expect(Socializer::Group.restricted.size).to eq(1)
+      end
+
+      it '.joinable has 1 group' do
+        expect(Socializer::Group.joinable.size).to eq(1)
+      end
+
+      it 'is has the right privacy level' do
+        expect(restricted_group.privacy_level.restricted?).to be_true
+      end
+
+      context 'and a person joins it' do
+        before do
+          restricted_group.join(person)
+          @membership = Membership.find_by(member_id: person.guid, group_id: restricted_group.id)
+        end
+
+        it 'creates an inactive membership' do
+          expect(@membership.active).to be_false
+        end
+      end
+    end
+
+    context 'when group is private' do
+      let(:private_group) { create(:socializer_group, privacy_level: 3) }
+      let(:person) { create(:socializer_person) }
+
+      before do
+        private_group.save!
+      end
+
+      it '.private has 1 group' do
+        expect(Socializer::Group.private.size).to eq(1)
+      end
+
+      it 'is has the right privacy level' do
+        expect(private_group.privacy_level.private?).to be_true
+      end
+
+      it 'cannot be joined' do
+        expect { private_group.join(person) }.to raise_error
+      end
+
+      context 'and a person gets invited' do
+        before do
+          private_group.invite(person)
+          @membership = Membership.find_by(member_id: person.guid, group_id: private_group.id)
+        end
+
+        it 'creates an inactive membership' do
+          expect(@membership.active).to be_false
+        end
+      end
+    end
+
+    context 'when inviting a person' do
+      let(:person) { create(:socializer_person) }
+
+      before do
+        group.invite(person)
+        @membership = Membership.find_by(member_id: person.guid, group_id: group.id)
+      end
+
+      it 'creates an inactive membership' do
+        expect(@membership.active).to be_false
+      end
+    end
+
+    context 'when having no member' do
+      let(:group_without_members) { create(:socializer_group, privacy_level: 3) }
+
+      before do
+        # the author is added as a member, so remove it first
+        group_without_members.memberships.first.destroy
+      end
+
+      it 'can be deleted' do
+        expect { group_without_members.destroy }.not_to raise_error
+      end
+    end
+
+    context 'when having at least one member' do
+      let(:group_with_members) { create(:socializer_group, privacy_level: 3) }
+
+      it 'cannot be deleted' do
+        expect { group_with_members.destroy }.to raise_error
+      end
+    end
+
+  end
+end

data/spec/models/socializer/identity_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Socializer
+  describe Identity do
+    let(:identity) { build(:socializer_identity) }
+
+    it 'has a valid factory' do
+      expect(identity).to be_valid
+    end
+
+    context 'mass assignment' do
+      it { expect(identity).to allow_mass_assignment_of(:name) }
+      it { expect(identity).to allow_mass_assignment_of(:email) }
+      it { expect(identity).to allow_mass_assignment_of(:password) }
+      it { expect(identity).to allow_mass_assignment_of(:password_confirmation) }
+    end
+
+    context 'validations' do
+      it { expect(identity).to validate_presence_of(:name) }
+      it { expect(identity).to validate_presence_of(:email) }
+      it { expect(create(:socializer_identity)).to validate_uniqueness_of(:email) }
+    end
+
+    it '#password' do
+      expect(identity).to respond_to(:password)
+    end
+
+    it '#password_confirmation' do
+      expect(identity).to respond_to(:password_confirmation)
+    end
+  end
+end

data/spec/models/socializer/membership_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module Socializer
+  describe Membership do
+    let(:membership) { build(:socializer_membership) }
+
+    it 'has a valid factory' do
+      expect(membership).to be_valid
+    end
+
+    it '#member' do
+      expect(membership).to respond_to(:member)
+    end
+
+    it '#group' do
+      expect(membership).to respond_to(:group)
+    end
+
+    it '#approve!' do
+      expect(membership).to respond_to(:approve!)
+    end
+
+    it '#confirm!' do
+      expect(membership).to respond_to(:confirm!)
+    end
+
+    it '#decline!' do
+      expect(membership).to respond_to(:decline!)
+    end
+
+    context 'when approved' do
+      let(:inactive_membership) { create(:socializer_membership, active: false) }
+
+      before do
+        inactive_membership.approve!
+      end
+
+      it 'becomes active' do
+        expect(inactive_membership.active).to be_true
+      end
+    end
+
+    context 'when confirmed' do
+      let(:inactive_membership) { create(:socializer_membership, active: false) }
+
+      before do
+        inactive_membership.confirm!
+      end
+
+      it 'becomes active' do
+        expect(inactive_membership.active).to be_true
+      end
+    end
+
+    context 'when declined' do
+      let(:inactive_membership) { create(:socializer_membership, active: false) }
+
+      before do
+        inactive_membership.decline!
+      end
+
+      it 'no longer exists' do
+        expect { inactive_membership.reload }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+  end
+end

data/spec/models/socializer/note_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Socializer
+  describe Note do
+    let(:note) { build(:socializer_note) }
+
+    it 'has a valid factory' do
+      expect(note).to be_valid
+    end
+
+    it '#content' do
+      expect(note).to respond_to(:content)
+    end
+
+    it '#author' do
+      expect(note).to respond_to(:author)
+    end
+  end
+end

data/spec/models/socializer/notification_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Socializer
+  describe Notification do
+
+    # Define a person for common testd instead of build one for each
+    let(:notification) { build(:socializer_notification) }
+
+    it 'has a valid factory' do
+      expect(notification).to be_valid
+    end
+
+    context 'mass assignment' do
+      it { expect(notification).to allow_mass_assignment_of(:read) }
+    end
+
+    context 'relationships' do
+      it { expect(notification).to belong_to(:activity) }
+      it { expect(notification).to belong_to(:activity_object) }
+    end
+
+    context 'validations' do
+      it { expect(notification).to validate_presence_of(:activity_id) }
+      it { expect(notification).to validate_presence_of(:activity_object_id) }
+    end
+
+  end
+end

data/spec/models/socializer/person_address_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Socializer
+  describe PersonAddress do
+    let(:person_address) { build(:socializer_person_address) }
+
+    it 'has a valid factory' do
+      expect(person_address).to be_valid
+    end
+
+    context 'mass assignment' do
+      it { expect(person_address).to allow_mass_assignment_of(:line1) }
+      it { expect(person_address).to allow_mass_assignment_of(:line2) }
+      it { expect(person_address).to allow_mass_assignment_of(:city) }
+      it { expect(person_address).to allow_mass_assignment_of(:postal_code_or_zip) }
+      it { expect(person_address).to allow_mass_assignment_of(:province_or_state) }
+      it { expect(person_address).to allow_mass_assignment_of(:country) }
+    end
+
+    context 'relationships' do
+      it { expect(person_address).to belong_to(:person) }
+    end
+
+    it { expect(enumerize(:category).in(:home, :work).with_default(:home)) }
+
+  end
+end