Further receive tests development

lib/diaspora/relayable.rb

@@ -71,7 +71,7 @@ module Diaspora
 
       unless comment_or_like.signature_valid?
         logger.warn "event=receive status=abort reason='object signature not valid' recipient=#{user.diaspora_handle} "\
-                    "sender=#{parent.author.diaspora_handle} payload_type=#{self.class} parent_id=#{parent.id}"
+                    "sender=#{comment_or_like.author.diaspora_handle} payload_type=#{self.class} parent_id=#{parent.id}"
         return
       end
 

spec/integration/federation/federation_helper.rb

@@ -17,10 +17,18 @@ def remote_user_on_pod_c
 end
 
 def generate_xml(entity, remote_user, user)
-  DiasporaFederation::Salmon::EncryptedSlap.generate_xml(
+  if @public
-    remote_user.diaspora_handle,
+    DiasporaFederation::Salmon::Slap.generate_xml(
-    OpenSSL::PKey::RSA.new(remote_user.encryption_key),
+      remote_user.diaspora_handle,
-    entity,
+      OpenSSL::PKey::RSA.new(remote_user.encryption_key),
-    OpenSSL::PKey::RSA.new(user.encryption_key)
+      entity
-  )
+    )
+  else
+    DiasporaFederation::Salmon::EncryptedSlap.generate_xml(
+      remote_user.diaspora_handle,
+      OpenSSL::PKey::RSA.new(remote_user.encryption_key),
+      entity,
+      OpenSSL::PKey::RSA.new(user.encryption_key)
+    )
+  end
 end

spec/integration/federation/federation_messages_generation.rb

@@ -0,0 +1,164 @@
+def generate_profile
+  @entity = FactoryGirl.build(:profile_entity, diaspora_id: remote_user_on_pod_b.person.diaspora_handle)
+
+  generate_xml(@entity, remote_user_on_pod_b, alice)
+end
+
+def generate_conversation
+  @entity = FactoryGirl.build(
+    :conversation_entity,
+    diaspora_id:     remote_user_on_pod_b.diaspora_handle,
+    participant_ids: "#{remote_user_on_pod_b.diaspora_handle};#{alice.diaspora_handle}"
+  )
+
+  generate_xml(@entity, remote_user_on_pod_b, alice)
+end
+
+def generate_status_message
+  @entity = FactoryGirl.build(
+    :status_message_entity,
+    diaspora_id: remote_user_on_pod_b.diaspora_handle,
+    public:      @public
+  )
+
+  generate_xml(@entity, remote_user_on_pod_b, alice)
+end
+
+def generate_forged_status_message
+  substitute_wrong_key(remote_user_on_pod_b, 1)
+  generate_status_message
+end
+
+def generate_reshare
+  @entity = FactoryGirl.build(
+    :reshare_entity,
+    root_diaspora_id: alice.diaspora_handle,
+    root_guid:        @local_target.guid,
+    diaspora_id:      remote_user_on_pod_b.diaspora_handle,
+    public:           true
+  )
+
+  generate_xml(@entity, remote_user_on_pod_b, alice)
+end
+
+def mock_private_key_for_user(user)
+  expect(DiasporaFederation.callbacks).to receive(:trigger)
+                                            .with(:fetch_private_key_by_diaspora_id, user.person.diaspora_handle)
+                                            .and_return(user.encryption_key)
+end
+
+def retraction_mock_callbacks(entity, sender)
+  return unless [
+    DiasporaFederation::Entities::SignedRetraction,
+    DiasporaFederation::Entities::RelayableRetraction
+  ].include?(entity.class)
+
+  mock_private_key_for_user(sender)
+
+  allow(DiasporaFederation.callbacks).to receive(:trigger)
+                                            .with(
+                                              :fetch_entity_author_id_by_guid,
+                                              entity.target_type,
+                                              entity.target_guid
+                                            )
+                                            .and_return(sender.encryption_key)
+end
+
+def generate_retraction(entity_name, target_object, sender=remote_user_on_pod_b)
+  @entity = FactoryGirl.build(
+    entity_name,
+    diaspora_id: sender.diaspora_handle,
+    target_guid: target_object.guid,
+    target_type: target_object.class.to_s
+  )
+
+  retraction_mock_callbacks(@entity, sender)
+
+  generate_xml(@entity, sender, alice)
+end
+
+def generate_forged_retraction(entity_name, target_object, sender=remote_user_on_pod_b)
+  times = 1
+  if %i(signed_retraction_entity relayable_retraction_entity).include?(entity_name)
+    times += 2
+  end
+
+  substitute_wrong_key(sender, times)
+  generate_retraction(entity_name, target_object, sender)
+end
+
+def generate_relayable_entity(entity_name, target, diaspora_id)
+  @entity = FactoryGirl.build(
+    entity_name,
+    conversation_guid: target.guid,
+    parent_guid:       target.guid,
+    diaspora_id:       diaspora_id,
+    poll_answer_guid:  target.respond_to?(:poll_answers) ? target.poll_answers.first.guid : nil
+  )
+end
+
+def mock_entity_author_private_key_unavailable(klass)
+  expect(DiasporaFederation.callbacks).to receive(:trigger)
+                                            .with(
+                                              :fetch_author_private_key_by_entity_guid,
+                                              klass.get_target_entity_type(@entity.to_h),
+                                              kind_of(String)
+                                            )
+                                            .and_return(nil)
+end
+
+def mock_entity_author_private_key_as(klass, key)
+  expect(DiasporaFederation.callbacks).to receive(:trigger)
+                                            .with(
+                                              :fetch_author_private_key_by_entity_guid,
+                                              klass.get_target_entity_type(@entity.to_h),
+                                              @remote_target.guid
+                                            )
+                                            .and_return(key)
+end
+
+def generate_relayable_local_parent(entity_name)
+  klass = FactoryGirl.factory_by_name(entity_name).build_class
+  generate_relayable_entity(entity_name, @local_target, remote_user_on_pod_b.person.diaspora_handle)
+
+  mock_private_key_for_user(remote_user_on_pod_b)
+  mock_entity_author_private_key_unavailable(klass)
+
+  generate_xml(@entity, remote_user_on_pod_b, alice)
+end
+
+def generate_relayable_remote_parent(entity_name)
+  klass = FactoryGirl.factory_by_name(entity_name).build_class
+  generate_relayable_entity(entity_name, @remote_target, remote_user_on_pod_c.person.diaspora_handle)
+
+  mock_private_key_for_user(remote_user_on_pod_c)
+  mock_entity_author_private_key_as(klass, remote_user_on_pod_b.encryption_key)
+
+  generate_xml(@entity, remote_user_on_pod_b, alice)
+end
+
+def substitute_wrong_key(user, times_number)
+  expect(user).to receive(:encryption_key).exactly(times_number).times.and_return(
+    OpenSSL::PKey::RSA.new(1024)
+  )
+end
+
+# Checks when a remote pod wants to send us a relayable without having a key for declared diaspora ID
+def generate_relayable_local_parent_wrong_author_key(entity_name)
+  substitute_wrong_key(remote_user_on_pod_b, 2)
+  generate_relayable_local_parent(entity_name)
+end
+
+# Checks when a remote pod B wants to send us a relayable with authorship from a remote pod C user
+# without having correct signature from him.
+def generate_relayable_remote_parent_wrong_author_key(entity_name)
+  substitute_wrong_key(remote_user_on_pod_c, 1)
+  generate_relayable_remote_parent(entity_name)
+end
+
+# Checks when a remote pod C wants to send us a relayable from its user, but bypassing the pod B where
+# remote status came from.
+def generate_relayable_remote_parent_wrong_parent_key(entity_name)
+  substitute_wrong_key(remote_user_on_pod_b, 2)
+  generate_relayable_remote_parent(entity_name)
+end

spec/integration/federation/receive_federation_messages_spec.rb

@@ -1,128 +1,176 @@
 require "spec_helper"
+require "diaspora_federation/test"
 require "integration/federation/federation_helper"
+require "integration/federation/federation_messages_generation"
 require "integration/federation/shared_receive_relayable"
 require "integration/federation/shared_receive_retraction"
+require "integration/federation/shared_receive_stream_items"
 
-describe Workers::ReceiveEncryptedSalmon do
+def post_private_message(recipient_guid, xml)
-  it "treats sharing request receive correctly" do
+  inlined_jobs do
-    entity = FactoryGirl.build(:request_entity, recipient_id: alice.diaspora_handle)
+    post "/receive/users/#{recipient_guid}", guid: recipient_guid, xml: xml
+  end
+end
 
-    expect(Diaspora::Fetcher::Public).to receive(:queue_for)
+def post_public_message(xml)
-    Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_xml(entity, remote_user_on_pod_c, alice))
+  inlined_jobs do
+    post "/receive/public", xml: xml
+  end
+end
 
-    new_contact = alice.contacts.find {|c| c.person.diaspora_handle == remote_user_on_pod_c.diaspora_handle }
+def post_message(recipient_guid, xml)
-    expect(new_contact).not_to be_nil
+  if @public
-    expect(new_contact.sharing).to eq(true)
+    post_public_message(xml)
+  else
+    post_private_message(recipient_guid, xml)
+  end
+end
+
+def set_up_sharing
+  contact = alice.contacts.find_or_initialize_by(person_id: remote_user_on_pod_b.person.id)
+  contact.sharing = true
+  contact.save
+end
+
+describe "Receive federation messages feature" do
+  before do
+    allow(DiasporaFederation.callbacks).to receive(:trigger)
+                                            .with(:queue_public_receive, any_args).and_call_original
+    allow(DiasporaFederation.callbacks).to receive(:trigger)
+                                            .with(:queue_private_receive, any_args).and_call_original
+    allow(DiasporaFederation.callbacks).to receive(:trigger)
+                                            .with(:save_person_after_webfinger, any_args).and_call_original
   end
 
-  it "doesn't save the status message if there is no sharing" do
+  context "with public receive" do
-    entity = FactoryGirl.build(:status_message_entity, diaspora_id: remote_user_on_pod_b.diaspora_handle, public: false)
-    Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_xml(entity, remote_user_on_pod_b, alice))
-
-    expect(StatusMessage.exists?(guid: entity.guid)).to be(false)
-  end
-
-  describe "with messages which require sharing" do
     before do
-      contact = alice.contacts.find_or_initialize_by(person_id: remote_user_on_pod_b.person.id)
+      @public = true
-      contact.sharing = true
-      contact.save
     end
 
-    it "treats status message receive correctly" do
+    it "receives account deletion correctly" do
-      entity = FactoryGirl.build(:status_message_entity,
+      post_public_message(
-                                 diaspora_id: remote_user_on_pod_b.diaspora_handle, public: false)
+        generate_xml(
-      Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_xml(entity, remote_user_on_pod_b, alice))
+          DiasporaFederation::Entities::AccountDeletion.new(diaspora_id: remote_user_on_pod_b.diaspora_handle),
+          remote_user_on_pod_b,
+          nil
+        )
+      )
 
-      expect(StatusMessage.exists?(guid: entity.guid)).to be(true)
+      expect(AccountDeletion.where(diaspora_handle: remote_user_on_pod_b.diaspora_handle).exists?).to be(true)
     end
 
-    it "doesn't accept status message with wrong signature" do
+    it "rejects account deletion with wrong diaspora_id" do
-      expect(remote_user_on_pod_b).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
+      delete_id = FactoryGirl.generate(:diaspora_id)
+      post_public_message(
+        generate_xml(
+          DiasporaFederation::Entities::AccountDeletion.new(diaspora_id: delete_id),
+          remote_user_on_pod_b,
+          nil
+        )
+      )
 
-      entity = FactoryGirl.build(:status_message_entity,
+      expect(AccountDeletion.where(diaspora_handle: delete_id).exists?).to be(false)
-                                 diaspora_id: remote_user_on_pod_b.diaspora_handle, public: false)
+      expect(AccountDeletion.where(diaspora_handle: remote_user_on_pod_b.diaspora_handle).exists?).to be(false)
-      Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_xml(entity, remote_user_on_pod_b, alice))
-
-      expect(StatusMessage.exists?(guid: entity.guid)).to be(false)
     end
 
-    describe "retractions for non-relayable objects" do
+    it "reshare of public post passes" do
-      %w(
+      @local_target = FactoryGirl.create(:status_message, author: alice.person, public: true)
-        retraction
+      post_public_message(generate_reshare)
-        signed_retraction
+
-      ).each do |retraction_entity_name|
+      expect(
-        context "with #{retraction_entity_name}" do
+        Reshare.where(root_guid: @local_target.guid, diaspora_handle: remote_user_on_pod_b.diaspora_handle).first
-          %w(status_message photo).each do |target|
+      ).not_to be_nil
-            context "with #{target}" do
-              it_behaves_like "it retracts non-relayable object" do
-                let(:target_object) { FactoryGirl.create(target.to_sym, author: remote_user_on_pod_b.person) }
-                let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
-              end
-            end
-          end
-        end
-      end
     end
 
-    describe "with messages which require a status to operate on" do
+    it "reshare of private post fails" do
-      let(:local_message) { FactoryGirl.create(:status_message, author: alice.person) }
+      @local_target = FactoryGirl.create(:status_message, author: alice.person, public: false)
-      let(:remote_message) { FactoryGirl.create(:status_message, author: remote_user_on_pod_b.person) }
+      post_public_message(generate_reshare)
 
-      %w(comment like participation).each do |entity|
+      expect(
-        context "with #{entity}" do
+        Reshare.where(root_guid: @local_target.guid, diaspora_handle: remote_user_on_pod_b.diaspora_handle).first
-          it_behaves_like "it deals correctly with a relayable" do
+      ).to be_nil
-            let(:entity_name) { "#{entity}_entity".to_sym }
+    end
-            let(:klass) { entity.camelize.constantize }
+
-          end
+    it_behaves_like "messages which are indifferent about sharing fact"
-        end
+
+    context "with sharing" do
+      before do
+        set_up_sharing
       end
 
-      describe "retractions for relayable objects" do
+      it_behaves_like "messages which are indifferent about sharing fact"
-        let(:sender) { remote_user_on_pod_b }
+      it_behaves_like "messages which can't be send without sharing"
+    end
+  end
 
-        %w(
+  context "with private receive" do
-          retraction
+    before do
-          signed_retraction
+      @public = false
-          relayable_retraction
+    end
-        ).each do |retraction_entity_name|
-          context "with #{retraction_entity_name}" do
-            context "with comment" do
-              it_behaves_like "it retracts object" do
-                # case for to-upstream federation
-                let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
-                let(:target_object) {
-                  FactoryGirl.create(:comment, author: remote_user_on_pod_b.person, post: local_message)
-                }
-              end
 
-              it_behaves_like "it retracts object" do
+    it "treats sharing request recive correctly" do
-                # case for to-downsteam federation
+      entity = FactoryGirl.build(:request_entity, recipient_id: alice.diaspora_handle)
-                let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
-                let(:target_object) {
-                  FactoryGirl.create(:comment, author: remote_user_on_pod_c.person, post: remote_message)
-                }
-              end
-            end
 
-            context "with like" do
+      expect(Diaspora::Fetcher::Public).to receive(:queue_for).exactly(1).times
-              it_behaves_like "it retracts object" do
-                # case for to-upstream federation
-                let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
-                let(:target_object) {
-                  FactoryGirl.create(:like, author: remote_user_on_pod_b.person, target: local_message)
-                }
-              end
 
-              it_behaves_like "it retracts object" do
+      post_private_message(alice.guid, generate_xml(entity, remote_user_on_pod_b, alice))
-                # case for to-downsteam federation
+
-                let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
+      expect(alice.contacts.count).to eq(2)
-                let(:target_object) {
+      new_contact = alice.contacts.order(created_at: :asc).last
-                  FactoryGirl.create(:like, author: remote_user_on_pod_c.person, target: remote_message)
+      expect(new_contact).not_to be_nil
-                }
+      expect(new_contact.sharing).to eq(true)
-              end
+      expect(new_contact.person.diaspora_handle).to eq(remote_user_on_pod_b.diaspora_handle)
-            end
+
-          end
+      expect(
+        Notifications::StartedSharing.where(
+          recipient_id: alice.id,
+          target_type:  "Person",
+          target_id:    remote_user_on_pod_b.person.id
+        ).first
+      ).not_to be_nil
+    end
+
+    it "doesn't save the private status message if there is no sharing" do
+      post_private_message(alice.guid, generate_status_message)
+
+      expect(StatusMessage.exists?(guid: @entity.guid)).to be(false)
+    end
+
+    context "with sharing" do
+      before do
+        set_up_sharing
+      end
+
+      it_behaves_like "messages which are indifferent about sharing fact"
+      it_behaves_like "messages which can't be send without sharing"
+
+      it "treats profile receive correctly" do
+        post_private_message(alice.guid, generate_profile)
+
+        expect(Profile.where(diaspora_handle: @entity.diaspora_id).exists?).to be(true)
+      end
+
+      it "receives conversation correctly" do
+        post_private_message(alice.guid, generate_conversation)
+
+        expect(Conversation.exists?(guid: @entity.guid)).to be(true)
+      end
+
+      context "with message" do
+        before do
+          @local_target = FactoryGirl.build(:conversation, author: alice.person)
+          @local_target.participants << remote_user_on_pod_b.person
+          @local_target.participants << remote_user_on_pod_c.person
+          @local_target.save
+          @remote_target = FactoryGirl.build(:conversation, author: remote_user_on_pod_b.person)
+          @remote_target.participants << alice.person
+          @remote_target.participants << remote_user_on_pod_c.person
+          @remote_target.save
+        end
+
+        it_behaves_like "it deals correctly with a relayable" do
+          let(:entity_name) { :message_entity }
+          let(:klass) { Message }
         end
       end
     end

spec/integration/federation/shared_receive_relayable.rb

@@ -1,93 +1,44 @@
 shared_examples_for "it deals correctly with a relayable" do
-  context "local" do
+  it "treats upstream receive correctly" do
-    let(:entity) {
+    expect(Postzord::Dispatcher).to receive(:build).with(alice, kind_of(klass)).and_call_original
-      FactoryGirl.build(
+    post_message(alice.guid, generate_relayable_local_parent(entity_name))
-        entity_name,
+    received_entity = klass.find_by(guid: @entity.guid)
-        parent_guid: local_message.guid,
+    expect(received_entity).not_to be_nil
-        diaspora_id: remote_user_on_pod_b.diaspora_handle
+    expect(received_entity.author.diaspora_handle).to eq(remote_user_on_pod_b.person.diaspora_handle)
-      )
-    }
-
-    def mock_private_keys
-      allow(DiasporaFederation.callbacks).to receive(:trigger)
-                                               .with(:fetch_private_key_by_diaspora_id,
-                                                     remote_user_on_pod_b.diaspora_handle)
-                                               .and_return(remote_user_on_pod_b.encryption_key)
-      allow(DiasporaFederation.callbacks).to receive(:trigger)
-                                               .with(:fetch_author_private_key_by_entity_guid, "Post", kind_of(String))
-                                               .and_return(nil)
-    end
-
-    it "treats upstream receive correctly" do
-      mock_private_keys
-
-      Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_xml(entity, remote_user_on_pod_b, alice))
-      received_entity = klass.find_by(guid: entity.guid)
-      expect(received_entity).not_to be_nil
-      expect(received_entity.author.diaspora_handle).to eq(remote_user_on_pod_b.person.diaspora_handle)
-    end
-
-    # Checks when a remote pod wants to send us a relayable without having a key for declared diaspora ID
-    it "rejects an upstream entity with a malformed author signature" do
-      allow(remote_user_on_pod_b).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
-      mock_private_keys
-
-      Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_xml(entity, remote_user_on_pod_b, alice))
-      expect(klass.exists?(guid: entity.guid)).to be(false)
-    end
   end
 
-  context "remote parent" do
+  it "rejects an upstream entity with a malformed author signature" do
-    let(:entity) {
+    expect(Postzord::Dispatcher).not_to receive(:build)
-      FactoryGirl.build(
+    post_message(
-        entity_name,
+      alice.guid,
-        parent_guid: remote_message.guid,
+      generate_relayable_local_parent_wrong_author_key(entity_name)
-        diaspora_id: remote_user_on_pod_c.diaspora_handle
+    )
-      )
+    expect(klass.exists?(guid: @entity.guid)).to be(false)
-    }
+  end
 
-    def mock_private_keys
+  it "treats downstream receive correctly" do
-      allow(DiasporaFederation.callbacks).to receive(:trigger)
+    expect(Postzord::Dispatcher).to receive(:build).with(alice, kind_of(klass)).and_call_original unless @public
-                                                .with(:fetch_private_key_by_diaspora_id,
+    post_message(alice.guid, generate_relayable_remote_parent(entity_name))
-                                                      remote_user_on_pod_c.diaspora_handle)
+    received_entity = klass.find_by(guid: @entity.guid)
-                                                .and_return(remote_user_on_pod_c.encryption_key)
+    expect(received_entity).not_to be_nil
+    expect(received_entity.author.diaspora_handle).to eq(remote_user_on_pod_c.person.diaspora_handle)
+  end
 
-      allow(DiasporaFederation.callbacks).to receive(:trigger)
+  it "rejects a downstream entity with a malformed author signature" do
-                                                .with(
+    expect(Postzord::Dispatcher).not_to receive(:build)
-                                                  :fetch_author_private_key_by_entity_guid,
+    post_message(
-                                                  "Post",
+      alice.guid,
-                                                  remote_message.guid
+      generate_relayable_remote_parent_wrong_author_key(entity_name)
-                                                )
+    )
-                                                .and_return(remote_user_on_pod_b.encryption_key)
+    expect(klass.exists?(guid: @entity.guid)).to be(false)
-    end
+  end
 
-    it "treats downstream receive correctly" do
+  it "declines downstream receive when sender signed with a wrong key" do
-      mock_private_keys
+    expect(Postzord::Dispatcher).not_to receive(:build)
-
+    post_message(
-      Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_xml(entity, remote_user_on_pod_b, alice))
+      alice.guid,
-      received_entity = klass.find_by(guid: entity.guid)
+      generate_relayable_remote_parent_wrong_parent_key(entity_name)
-      expect(received_entity).not_to be_nil
+    )
-      expect(received_entity.author.diaspora_handle).to eq(remote_user_on_pod_c.diaspora_handle)
+    expect(klass.exists?(guid: @entity.guid)).to be(false)
-    end
-
-    # Checks when a remote pod B wants to send us a relayable with authorship from a remote pod C user
-    # without having correct signature from him.
-    it "rejects a downstream entity with a malformed author signature" do
-      allow(remote_user_on_pod_c).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
-      mock_private_keys
-
-      Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_xml(entity, remote_user_on_pod_b, alice))
-      expect(klass.exists?(guid: entity.guid)).to be(false)
-    end
-
-    # Checks when a remote pod C wants to send us a relayable from its user, but bypassing the pod B where
-    # remote status came from.
-    it "declines downstream receive when sender signed with a wrong key" do
-      allow(remote_user_on_pod_b).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
-      mock_private_keys
-
-      Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_xml(entity, remote_user_on_pod_b, alice))
-      expect(klass.exists?(guid: entity.guid)).to be(false)
-    end
   end
 end

spec/integration/federation/shared_receive_retraction.rb

@@ -1,41 +1,22 @@
-def mock_private_keys_for_retraction(entity_name, entity, sender)
-  if %i(signed_retraction_entity relayable_retraction_entity).include?(entity_name)
-    allow(DiasporaFederation.callbacks).to receive(:trigger)
-                                             .with(:fetch_private_key_by_diaspora_id, sender.diaspora_handle)
-                                             .and_return(sender.encryption_key)
-  end
-  if entity_name == :relayable_retraction_entity
-    allow(DiasporaFederation.callbacks).to receive(:trigger)
-                                             .with(
-                                               :fetch_entity_author_id_by_guid,
-                                               entity.target_type,
-                                               entity.target_guid
-                                             )
-                                             .and_return(sender.encryption_key)
-  end
-end
-
-def generate_retraction(entity_name, target_object, sender)
-  entity = FactoryGirl.build(
-    entity_name,
-    diaspora_id: sender.diaspora_handle,
-    target_guid: target_object.guid,
-    target_type: target_object.class.to_s
-  )
-
-  mock_private_keys_for_retraction(entity_name, entity, sender)
-  generate_xml(entity, sender, alice)
-end
-
 shared_examples_for "it retracts non-relayable object" do
-  it_behaves_like "it retracts object" do
+  it "retracts object by a correct retraction message" do
-    let(:sender) { remote_user_on_pod_b }
+    target_klass = target_object.class.to_s.constantize
+    post_message(alice.guid, generate_retraction(entity_name, target_object))
+
+    expect(target_klass.exists?(guid: target_object.guid)).to be(false)
+  end
+
+  it "doesn't retract object when retraction has wrong signatures" do
+    target_klass = target_object.class.to_s.constantize
+    post_message(alice.guid, generate_forged_retraction(entity_name, target_object))
+
+    expect(target_klass.exists?(guid: target_object.guid)).to be(true)
   end
 
   it "doesn't retract object when sender is different from target object" do
     target_klass = target_object.class.to_s.constantize
-    Workers::ReceiveEncryptedSalmon.new.perform(
+    post_message(
-      alice.id,
+      alice.guid,
       generate_retraction(entity_name, target_object, remote_user_on_pod_c)
     )
 
@@ -43,20 +24,20 @@ shared_examples_for "it retracts non-relayable object" do
   end
 end
 
-shared_examples_for "it retracts object" do
+shared_examples_for "it retracts relayable object" do
   it "retracts object by a correct message" do
     target_klass = target_object.class.to_s.constantize
-    Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_retraction(entity_name, target_object, sender))
+    post_message(alice.guid, generate_retraction(entity_name, target_object, sender))
 
     expect(target_klass.exists?(guid: target_object.guid)).to be(false)
   end
 
   it "doesn't retract object when retraction has wrong signatures" do
     target_klass = target_object.class.to_s.constantize
-
+    post_message(
-    allow(sender).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
+      alice.guid,
-
+      generate_forged_retraction(entity_name, target_object, sender)
-    Workers::ReceiveEncryptedSalmon.new.perform(alice.id, generate_retraction(entity_name, target_object, sender))
+    )
 
     expect(target_klass.exists?(guid: target_object.guid)).to be(true)
   end

spec/integration/federation/shared_receive_stream_items.rb

@@ -0,0 +1,166 @@
+# by "stream items" we mean everything that could appear in the stream - post, comment, like, poll, etc and therefore
+# could be send either publicly or privately
+def set_up_messages
+  @local_target = FactoryGirl.create(:status_message, author: alice.person, public: @public)
+  @remote_target = FactoryGirl.create(:status_message, author: remote_user_on_pod_b.person, public: @public)
+end
+
+shared_examples_for "messages which are indifferent about sharing fact" do
+  it "treats status message receive correctly" do
+    post_message(alice.guid, generate_status_message)
+
+    expect(StatusMessage.exists?(guid: @entity.guid)).to be(true)
+  end
+
+  it "doesn't accept status message with wrong signature" do
+    post_message(alice.guid, generate_forged_status_message)
+
+    expect(StatusMessage.exists?(guid: @entity.guid)).to be(false)
+  end
+
+  describe "with messages which require a status to operate on" do
+    before do
+      set_up_messages
+    end
+
+    describe "notifications are sent where required" do
+      it "for comment on local post" do
+        post_message(alice.guid, generate_relayable_local_parent(:comment_entity))
+
+        expect(
+          Notifications::CommentOnPost.where(
+            recipient_id: alice.id,
+            target_type:  "Post",
+            target_id:    @local_target.id
+          ).first
+        ).not_to be_nil
+      end
+
+      it "for like on local post" do
+        post_message(alice.guid, generate_relayable_local_parent(:like_entity))
+
+        expect(
+          Notifications::Liked.where(
+            recipient_id: alice.id,
+            target_type:  "Post",
+            target_id:    @local_target.id
+          ).first
+        ).not_to be_nil
+      end
+    end
+
+    %w(comment like participation).each do |entity|
+      context "with #{entity}" do
+        it_behaves_like "it deals correctly with a relayable" do
+          let(:entity_name) { "#{entity}_entity".to_sym }
+          let(:klass) { entity.camelize.constantize }
+        end
+      end
+    end
+
+    context "with poll_participation" do
+      before do
+        @local_target = FactoryGirl.create(:poll, status_message: @local_target)
+        @remote_target = FactoryGirl.create(:poll, status_message: @remote_target)
+      end
+
+      it_behaves_like "it deals correctly with a relayable" do
+        let(:entity_name) { :poll_participation_entity }
+        let(:klass) { PollParticipation }
+      end
+    end
+  end
+end
+
+shared_examples_for "messages which can't be send without sharing" do
+  # retractions shouldn't depend on sharing fact
+  describe "retractions for non-relayable objects" do
+    %w(
+      retraction
+      signed_retraction
+    ).each do |retraction_entity_name|
+      context "with #{retraction_entity_name}" do
+        %w(status_message photo).each do |target|
+          context "with #{target}" do
+            it_behaves_like "it retracts non-relayable object" do
+              let(:target_object) { FactoryGirl.create(target.to_sym, author: remote_user_on_pod_b.person) }
+              let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "with messages which require a status to operate on" do
+    before do
+      set_up_messages
+    end
+
+    # this one shouldn't depend on the sharing fact. this must be fixed
+    describe "notifications are sent where required" do
+      it "for comment on remote post where we participate" do
+        alice.participate!(@remote_target)
+        post_message(alice.guid, generate_relayable_remote_parent(:comment_entity))
+
+        expect(
+          Notifications::AlsoCommented.where(
+            recipient_id: alice.id,
+            target_type:  "Post",
+            target_id:    @remote_target.id
+          ).first
+        ).not_to be_nil
+      end
+    end
+
+    describe "retractions for relayable objects" do
+      %w(
+        retraction
+        signed_retraction
+        relayable_retraction
+      ).each do |retraction_entity_name|
+        context "with #{retraction_entity_name}" do
+          context "with comment" do
+            it_behaves_like "it retracts relayable object" do
+              # case for to-upstream federation
+              let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
+              let(:target_object) {
+                FactoryGirl.create(:comment, author: remote_user_on_pod_b.person, post: @local_target)
+              }
+              let(:sender) { remote_user_on_pod_b }
+            end
+
+            it_behaves_like "it retracts relayable object" do
+              # case for to-downsteam federation
+              let(:target_object) {
+                FactoryGirl.create(:comment, author: remote_user_on_pod_c.person, post: @remote_target)
+              }
+              let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
+              let(:sender) { remote_user_on_pod_b }
+            end
+          end
+
+          context "with like" do
+            it_behaves_like "it retracts relayable object" do
+              # case for to-upstream federation
+              let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
+              let(:target_object) {
+                FactoryGirl.create(:like, author: remote_user_on_pod_b.person, target: @local_target)
+              }
+              let(:sender) { remote_user_on_pod_b }
+            end
+
+            it_behaves_like "it retracts relayable object" do
+              # case for to-downsteam federation
+              let(:target_object) {
+                FactoryGirl.create(:like, author: remote_user_on_pod_c.person, target: @remote_target)
+              }
+              let(:entity_name) { "#{retraction_entity_name}_entity".to_sym }
+              let(:sender) { remote_user_on_pod_b }
+            end
+          end
+        end
+      end
+    end
+  end
+end