message_train 0.1.7 → 0.2.0

data/spec/models/message_train/conversation_spec.rb

@@ -2,23 +2,61 @@ require 'rails_helper'
 
 module MessageTrain
   RSpec.describe Conversation do
+    include_context 'loaded site'
+
     describe 'Model' do
       it { should have_many :messages }
       it { should have_many :ignores }
       it { should have_many(:receipts).through(:messages) }
+      it { should have_many(:attachments).through(:messages) }
     end
+
     describe 'Scopes and Methods' do
-      include_context 'loaded site'
+
+      describe '.ignored' do
+        let(:results) { MessageTrain::Conversation.ignored(first_user) }
+        subject { results.first.is_ignored?(first_user) }
+        it { should be true }
+      end
+
+      describe '.unignored' do
+        let(:results) { MessageTrain::Conversation.unignored(first_user) }
+        subject { results.first.is_ignored?(first_user) }
+        it { should be false }
+      end
+
+      describe '.with_drafts_by' do
+        subject { MessageTrain::Conversation.with_drafts_by(first_user) }
+        it { should include draft_conversation }
+      end
+
+      describe '.with_ready_for' do
+        subject { MessageTrain::Conversation.with_ready_for(first_user) }
+        it { should include unread_conversation }
+      end
+
+      describe '.with_messages_for' do
+        subject { MessageTrain::Conversation.with_messages_for(first_user) }
+        it { should include unread_conversation }
+      end
+
+      describe '.with_messages_through' do
+        subject { MessageTrain::Conversation.with_messages_through(first_group) }
+        it { should include group_conversation }
+      end
+
       describe '#default_recipients_for' do
         subject { sent_conversation.default_recipients_for(first_user) }
         it { should include second_user }
         it { should_not include first_user }
         it { should_not include third_user }
       end
+
       describe '#set_ignored and #is_ignored?' do
         subject { ignored_conversation.is_ignored?(first_user) }
         it { should be true }
       end
+
       describe '#set_unignored' do
         before do
           ignored_conversation.set_unignored(first_user)
@@ -26,6 +64,7 @@ module MessageTrain
         subject { ignored_conversation.is_ignored?(first_user) }
         it { should be false }
       end
+
       describe '#mark and #includes_read_for?' do
         before do
           unread_conversation.mark(:read, first_user)
@@ -33,15 +72,12 @@ module MessageTrain
         subject { unread_conversation.includes_read_for?(first_user) }
         it { should be true }
       end
+
       describe '#includes_drafts_by?' do
         subject { draft_conversation.includes_drafts_by?(first_user) }
         it { should be true }
       end
-      describe '.with_drafts_by' do
-        subject { MessageTrain::Conversation.with_drafts_by(first_user) }
-        its(:first) { should be_a MessageTrain::Conversation }
-        its(:count) { should eq 1 }
-      end
+
       describe 'Dynamic Methods' do
         describe '.trashed_for' do
           subject { MessageTrain::Conversation.with_trashed_for(first_user) }
@@ -72,6 +108,14 @@ module MessageTrain
           subject { trashed_conversation.includes_trashed_to?(first_user) }
           it { should be true }
         end
+        describe '#includes_ready_by?' do
+          subject { sent_conversation.includes_ready_by?(first_user) }
+          it { should be true }
+        end
+        describe '#includes_ready_to?' do
+          subject { unread_conversation.includes_ready_to?(first_user) }
+          it { should be true }
+        end
         describe '#includes_read_to?' do
           subject { read_conversation.includes_read_to?(first_user) }
           it { should be true }
@@ -92,7 +136,41 @@ module MessageTrain
           subject { sent_conversation.includes_receipts_for?(first_user) }
           it { should be true }
         end
+        describe 'responds to :includes_ready_for?' do
+          subject { unread_conversation.respond_to? :includes_ready_for? }
+          it { should be true }
+        end
+        describe '.find_by_subject' do
+          # Testing super on method_missing
+          subject { MessageTrain::Conversation.find_by_subject('Unread Conversation') }
+          it { should be_a(MessageTrain::Conversation) }
+        end
+        describe '#missing_method' do
+          # Testing super on method_missing
+          it 'raises a NoMethodError' do
+            expect {unread_conversation.missing_method}.to raise_error(NoMethodError)
+          end
+        end
+        describe '.with_ready_by' do
+          subject { MessageTrain::Conversation.with_ready_by(first_user) }
+          it { should include sent_conversation }
+          it { should_not include draft_conversation }
+          it { should_not include unread_conversation }
+        end
+        describe '.with_ready_to' do
+          subject { MessageTrain::Conversation.with_ready_to(first_user) }
+          it { should_not include sent_conversation }
+          it { should_not include draft_conversation }
+          it { should include unread_conversation }
+        end
+        describe '.with_messages_by' do
+          subject { MessageTrain::Conversation.with_messages_by(first_user) }
+          it { should include sent_conversation }
+          it { should include draft_conversation }
+          it { should_not include unread_conversation }
+        end
       end
+
     end
   end
 end

data/spec/models/message_train/ignore_spec.rb

@@ -14,10 +14,6 @@ module MessageTrain
         subject { ignored_conversation.ignores.find_all_by_participant(first_user) }
         its(:first) { should be_a MessageTrain::Ignore }
       end
-      describe '.conversation_ids' do
-        subject { MessageTrain::Ignore.conversation_ids }
-        it { should include ignored_conversation.id }
-      end
       describe '.conversations' do
         subject { MessageTrain::Ignore.conversations }
         it { should include ignored_conversation }

data/spec/models/message_train/message_spec.rb

@@ -23,34 +23,55 @@ module MessageTrain
         its(:draft) { should be true }
       end
       context 'generates receipts when present' do
-        subject { sent_conversation.messages.first }
+        subject { sent_message }
         its(:sender) { should eq first_user }
         its(:receipts) { should have_exactly(2).items } # i.e. sender and recipient
         its(:recipients) { should include second_user }
         its(:draft) { should be false }
       end
+      context 'generates error when recipient_to_save does not exist' do
+        let(:message) { first_user.box(:in).send_message(subject: 'Message with missing recipient', recipients_to_save: { 'users' => 'missing-user' }, body: 'Foo.') }
+        subject { message.errors.full_messages.to_sentence }
+        it { should eq 'Recipient missing-user not found' }
+      end
     end
     describe 'Scopes and Methods' do
+      context '.ready' do
+        subject { MessageTrain::Message.ready.conversations }
+        it { should include sent_conversation }
+        it { should_not include draft_conversation }
+      end
       context '.drafts' do
         subject { MessageTrain::Message.drafts.first.conversation }
         it { should eq draft_conversation }
       end
       context '.by' do
         subject { MessageTrain::Message.by(first_user) }
-        it { should include sent_conversation.messages.first }
-        it { should include draft_conversation.messages.first }
+        it { should include sent_message }
+        it { should include draft_message }
       end
       context '.drafts_by' do
-        subject { MessageTrain::Message.drafts_by(first_user).first.conversation }
-        it { should eq draft_conversation }
+        subject { MessageTrain::Message.drafts_by(first_user).first }
+        it { should eq draft_message }
+      end
+      context '.find_by_subject' do
+        # Testing super on method_missing
+        subject { MessageTrain::Message.find_by_subject('Sent Conversation') }
+        it { should eq sent_message }
+      end
+      describe '#missing_method' do
+        # Testing super on method_missing
+        it 'raises a NoMethodError' do
+          expect {unread_message.missing_method}.to raise_error(NoMethodError)
+        end
       end
       context '.with_receipts_by' do
-        subject { MessageTrain::Message.with_receipts_by(first_user).last.conversation }
-        it { should eq sent_conversation }
+        subject { MessageTrain::Message.with_receipts_by(first_user).last }
+        it { should eq sent_message }
       end
       context '.with_receipts_to' do
-        subject { MessageTrain::Message.with_receipts_to(first_user).last.conversation }
-        it { should eq unread_conversation }
+        subject { MessageTrain::Message.with_receipts_to(first_user).last }
+        it { should eq unread_message }
       end
       context '.with_trashed_to and #is_trashed_to?' do
         subject { trashed_conversation.messages.with_trashed_to(first_user).first.is_trashed_to?(first_user) }
@@ -68,16 +89,32 @@ module MessageTrain
         before do
           read_conversation.messages.mark(:trash, first_user)
         end
-        subject { read_conversation.messages.first.is_trashed_to?(first_user) }
+        subject { read_message.is_trashed_to?(first_user) }
         it { should be true }
       end
       context '#mark' do
         before do
-          read_conversation.messages.first.mark(:unread, first_user)
+          read_message.mark(:unread, first_user)
         end
-        subject { read_conversation.messages.first.is_read_to?(first_user) }
+        subject { read_message.is_read_to?(first_user) }
         it { should be false }
       end
+      context '#recipients' do
+        subject { unread_message.recipients.first }
+        it { should eq first_user }
+      end
+      context '.conversation_ids' do
+        subject { unread_conversation.messages.conversation_ids }
+        its(:first) { should eq unread_conversation.id }
+      end
+      context '.conversations' do
+        subject { unread_conversation.messages.conversations }
+        its(:first) { should eq unread_conversation }
+      end
+      describe 'responds to :is_message_by?' do
+        subject { unread_message.respond_to? :is_message_by? }
+        it { should be true }
+      end
     end
   end
 end

data/spec/models/message_train/receipt_spec.rb

@@ -2,16 +2,19 @@ require 'rails_helper'
 
 module MessageTrain
   RSpec.describe Receipt do
+    include_context 'loaded site'
+
     describe 'Model' do
       # Relationships
       it { should belong_to :message }
       it { should belong_to :recipient }
+      it { should belong_to :received_through }
       # Validations
       it { should validate_presence_of :message }
       it { should validate_presence_of :recipient }
     end
+
     describe 'Scopes and Methods' do
-      include_context 'loaded site'
       describe '.sender_receipt' do
         subject { MessageTrain::Receipt.sender_receipt.first }
         its(:sender) { should be true }
@@ -28,6 +31,11 @@ module MessageTrain
         it { should include trashed_conversation }
         it { should include read_conversation }
       end
+      describe '.find_by_recipient' do
+        # Testing super on method_missing
+        subject { MessageTrain::Receipt.find_by_recipient_type('User') }
+        it { should be_a(MessageTrain::Receipt) }
+      end
       describe '.receipts_to' do
         subject { MessageTrain::Receipt.receipts_to(first_user) }
         its(:first) { should be_a MessageTrain::Receipt }
@@ -35,7 +43,7 @@ module MessageTrain
       end
       describe '.trashed_to' do
         subject { MessageTrain::Receipt.trashed_to(first_user).first.message.conversation }
-        its(:subject) { should eq 'Trashed Conversation' }
+        its(:subject) { should eq 'Membered Group Trashed Conversation' }
       end
       describe '.untrashed_to' do
         subject { MessageTrain::Receipt.untrashed_to(first_user).first }
@@ -43,11 +51,11 @@ module MessageTrain
       end
       describe '.read_to' do
         subject { MessageTrain::Receipt.read_to(first_user).first.message.conversation }
-        its(:subject) { should eq 'Read Conversation' }
+        its(:subject) { should eq 'Membered Group Read Conversation' }
       end
       describe '.deleted_to' do
         subject { MessageTrain::Receipt.deleted_to(first_user).first.message.conversation }
-        its(:subject) { should eq 'Deleted Conversation' }
+        its(:subject) { should eq 'Membered Group Deleted Conversation' }
       end
       describe '.undeleted_to' do
         subject { MessageTrain::Receipt.undeleted_to(first_user).first }
@@ -55,19 +63,47 @@ module MessageTrain
       end
       describe '.message_ids' do
         subject { MessageTrain::Receipt.receipts_by(first_user).message_ids }
-        it { should include sent_conversation.messages.first.id }
+        it { should include sent_message.id }
       end
       describe '.messages' do
         subject { MessageTrain::Receipt.receipts_by(first_user).messages }
-        it { should include sent_conversation.messages.first }
+        it { should include sent_message }
       end
       describe '#mark' do
         before do
-          unread_conversation.messages.first.receipts.for(first_user).first.mark(:read)
+          unread_message.receipts.for(first_user).first.mark(:read)
         end
-        subject { unread_conversation.messages.first.is_read_to?(first_user) }
+        subject { unread_message.is_read_to?(first_user) }
         it { should be true }
       end
+      describe '.message_ids' do
+        subject { first_user.receipts.message_ids }
+        it { should include unread_message.id }
+        it { should include sent_message.id }
+        it { should include read_message.id }
+        it { should include draft_message.id }
+      end
+      describe '.messages' do
+        subject { first_user.receipts.messages }
+        it { should include unread_message }
+        it { should include sent_message }
+        it { should include read_message }
+        it { should include draft_message }
+      end
+      describe '.conversation_ids' do
+        subject { first_user.receipts.conversation_ids }
+        it { should include unread_conversation.id }
+        it { should include sent_conversation.id }
+        it { should include read_conversation.id }
+        it { should include draft_conversation.id }
+      end
+      describe '.conversations' do
+        subject { first_user.receipts.conversations }
+        it { should include unread_conversation }
+        it { should include sent_conversation }
+        it { should include read_conversation }
+        it { should include draft_conversation }
+      end
     end
   end
 end

data/spec/models/message_train/unsubscribe_spec.rb

@@ -0,0 +1,16 @@
+require 'rails_helper'
+
+module MessageTrain
+  RSpec.describe Unsubscribe do
+    include_context 'loaded site'
+
+    describe 'Model' do
+      # Relationships
+      it { should belong_to :recipient }
+      it { should belong_to :from }
+      # Validations
+      it { should validate_presence_of :recipient }
+      it { should validate_presence_of :from }
+    end
+  end
+end

data/spec/models/role_spec.rb

@@ -0,0 +1,125 @@
+require 'rails_helper'
+
+RSpec.describe Role do
+  describe 'Model' do
+    # MessageTrain Gem
+    it { should have_many(:receipts) }
+  end
+
+  describe 'Scopes and Methods from Message Train' do
+    include_context 'loaded site'
+
+    describe '#slug_part' do
+      subject { superadmin_role.slug_part }
+      it { should eq 'superadmin' }
+    end
+
+    describe '#path_part' do
+      subject { superadmin_role.path_part }
+      it { should eq 'roles:superadmin' }
+    end
+
+    describe '#valid_senders' do
+      subject { superadmin_role.valid_senders }
+      it { should include superadmin_user }
+      it { should_not include admin_user }
+    end
+
+    describe '#allows_sending_by?' do
+      context 'when user is a superadmin' do
+        subject { admin_role.allows_sending_by?(superadmin_user) }
+        it { should be true }
+      end
+      context 'when user is not an owner' do
+        subject { admin_role.allows_sending_by?(admin_user) }
+        it { should be false }
+      end
+    end
+
+    describe '#valid_recipients' do
+      subject { admin_role.valid_recipients }
+      it { should_not include first_user }
+      it { should include admin_user }
+    end
+
+    describe '#allows_receiving_by?' do
+      context 'when user is a member' do
+        subject { admin_role.allows_receiving_by?(admin_user) }
+        it { should be true }
+      end
+      context 'when user is not a member' do
+        subject { admin_role.allows_receiving_by?(first_user) }
+        it { should be false }
+      end
+    end
+
+    describe '#self_collection' do
+      subject { admin_role.self_collection }
+      it { should be_a ActiveRecord::Relation }
+      it { should eq [admin_role] }
+    end
+
+    describe '#conversations' do
+      subject { admin_role.conversations(:in, admin_user) }
+      its(:first) { should be_a MessageTrain::Conversation }
+      its(:count) { should eq 1 }
+    end
+
+    describe '#boxes_for_participant' do
+      context 'when participant is a valid sender' do
+        subject { admin_role.boxes_for_participant(superadmin_user).collect { |x| x.division } }
+        it { should_not include :in }
+        it { should include :sent }
+        it { should include :drafts }
+        it { should include :all }
+        it { should include :trash }
+        it { should_not include :ignored }
+      end
+      context 'when participant is a valid recipient' do
+        subject { admin_role.boxes_for_participant(admin_user).collect { |x| x.division } }
+        it { should include :in }
+        it { should_not include :sent }
+        it { should_not include :drafts }
+        it { should include :all }
+        it { should include :trash }
+        it { should include :ignored }
+      end
+    end
+
+    describe '#all_conversations' do
+      context 'when participant is a valid sender' do
+        subject { admin_role.all_conversations(superadmin_user) }
+        its(:first) { should be_a MessageTrain::Conversation }
+        it { should_not include unread_conversation }
+        it { should include role_conversation }
+        it { should_not include role_draft } # Because received_through not set on sender receipts
+      end
+      context 'when participant is a valid recipient' do
+        subject { admin_role.all_conversations(admin_user) }
+        its(:first) { should be_a MessageTrain::Conversation }
+        it { should_not include unread_conversation }
+        it { should include role_conversation }
+        it { should_not include role_draft }
+      end
+    end
+
+    describe '#all_messages' do
+      context 'when participant is a valid sender' do
+        subject { admin_role.all_messages(superadmin_user) }
+        its(:first) { should be_a MessageTrain::Message }
+        it { should_not include unread_message }
+        it { should include role_message }
+        it { should_not include role_draft_message } # Because received_through not set on sender receipts
+      end
+      context 'when participant is a valid recipient' do
+        subject { admin_role.all_messages(admin_user) }
+        its(:first) { should be_a MessageTrain::Message }
+        it { should_not include unread_message }
+        it { should include role_message }
+        it { should_not include role_draft_message }
+      end
+    end
+
+  end
+
+end