Commit 812510b4 authored by Benjamin Neff's avatar Benjamin Neff Committed by Dennis Schubert

refactoring tests again

closes #6595
parent b6c7f004
def remote_user_on_pod_b
@remote_on_b ||= FactoryGirl.build(:user).tap do |user|
user.person = FactoryGirl.create(:person,
profile: FactoryGirl.build(:profile),
serialized_public_key: user.encryption_key.public_key.export,
diaspora_handle: "#{user.username}@remote-b.net")
end
@remote_on_b ||= create_remote_user("remote-b.net")
end
def remote_user_on_pod_c
@remote_on_c ||= FactoryGirl.build(:user).tap do |user|
@remote_on_c ||= create_remote_user("remote-c.net")
end
def create_remote_user(pod)
FactoryGirl.build(:user).tap do |user|
user.person = FactoryGirl.create(:person,
profile: FactoryGirl.build(:profile),
serialized_public_key: user.encryption_key.public_key.export,
diaspora_handle: "#{user.username}@remote-c.net")
diaspora_handle: "#{user.username}@#{pod}")
allow(DiasporaFederation.callbacks).to receive(:trigger)
.with(:fetch_private_key_by_diaspora_id, user.diaspora_handle) {
user.encryption_key
}
end
end
def generate_xml(entity, remote_user, user)
if @public
DiasporaFederation::Salmon::Slap.generate_xml(
def create_relayable_entity(entity_name, target, diaspora_id, parent_author_key)
target_entity_type = FactoryGirl.factory_by_name(entity_name).build_class.get_target_entity_type(@entity.to_h)
expect(DiasporaFederation.callbacks).to receive(:trigger)
.with(
:fetch_author_private_key_by_entity_guid,
target_entity_type,
target.guid
)
.and_return(parent_author_key)
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 generate_xml(entity, remote_user, recipient=nil)
if recipient
DiasporaFederation::Salmon::EncryptedSlap.generate_xml(
remote_user.diaspora_handle,
OpenSSL::PKey::RSA.new(remote_user.encryption_key),
entity
entity,
OpenSSL::PKey::RSA.new(recipient.encryption_key)
)
else
DiasporaFederation::Salmon::EncryptedSlap.generate_xml(
DiasporaFederation::Salmon::Slap.generate_xml(
remote_user.diaspora_handle,
OpenSSL::PKey::RSA.new(remote_user.encryption_key),
entity,
OpenSSL::PKey::RSA.new(user.encryption_key)
entity
)
end
end
def post_message(xml, recipient=nil)
if recipient
inlined_jobs do
post "/receive/users/#{recipient.guid}", guid: recipient.guid, xml: xml
end
else
inlined_jobs do
post "/receive/public", xml: xml
end
end
end
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
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"
def post_private_message(recipient_guid, xml)
inlined_jobs do
post "/receive/users/#{recipient_guid}", guid: recipient_guid, xml: xml
end
end
def post_public_message(xml)
inlined_jobs do
post "/receive/public", xml: xml
end
end
def post_message(recipient_guid, xml)
if @public
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
let(:sender) { remote_user_on_pod_b }
let(:sender_id) { remote_user_on_pod_b.diaspora_handle }
context "with public receive" do
before do
@public = true
end
let(:recipient) { nil }
it "receives account deletion correctly" do
post_public_message(
generate_xml(
DiasporaFederation::Entities::AccountDeletion.new(diaspora_id: remote_user_on_pod_b.diaspora_handle),
remote_user_on_pod_b,
nil
)
)
post_message(generate_xml(DiasporaFederation::Entities::AccountDeletion.new(diaspora_id: sender_id), sender))
expect(AccountDeletion.where(diaspora_handle: remote_user_on_pod_b.diaspora_handle).exists?).to be(true)
expect(AccountDeletion.exists?(diaspora_handle: sender_id)).to be_truthy
end
it "rejects account deletion with wrong diaspora_id" do
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
)
)
post_message(generate_xml(DiasporaFederation::Entities::AccountDeletion.new(diaspora_id: delete_id), sender))
expect(AccountDeletion.where(diaspora_handle: delete_id).exists?).to be(false)
expect(AccountDeletion.where(diaspora_handle: remote_user_on_pod_b.diaspora_handle).exists?).to be(false)
expect(AccountDeletion.exists?(diaspora_handle: delete_id)).to be_falsey
expect(AccountDeletion.exists?(diaspora_handle: sender_id)).to be_falsey
end
it "reshare of public post passes" do
@local_target = FactoryGirl.create(:status_message, author: alice.person, public: true)
post_public_message(generate_reshare)
context "reshare" do
it "reshare of public post passes" do
post = FactoryGirl.create(:status_message, author: alice.person, public: true)
reshare = FactoryGirl.build(
:reshare_entity, root_diaspora_id: alice.diaspora_handle, root_guid: post.guid, diaspora_id: sender_id)
post_message(generate_xml(reshare, sender))
expect(
Reshare.where(root_guid: @local_target.guid, diaspora_handle: remote_user_on_pod_b.diaspora_handle).first
).not_to be_nil
end
expect(Reshare.exists?(root_guid: post.guid, diaspora_handle: sender_id)).to be_truthy
end
it "reshare of private post fails" do
@local_target = FactoryGirl.create(:status_message, author: alice.person, public: false)
post_public_message(generate_reshare)
it "reshare of private post fails" do
post = FactoryGirl.create(:status_message, author: alice.person, public: false)
reshare = FactoryGirl.build(
:reshare_entity, root_diaspora_id: alice.diaspora_handle, root_guid: post.guid, diaspora_id: sender_id)
post_message(generate_xml(reshare, sender))
expect(
Reshare.where(root_guid: @local_target.guid, diaspora_handle: remote_user_on_pod_b.diaspora_handle).first
).to be_nil
expect(Reshare.exists?(root_guid: post.guid, diaspora_handle: sender_id)).to be_falsey
end
end
it_behaves_like "messages which are indifferent about sharing fact"
context "with sharing" do
before do
set_up_sharing
contact = alice.contacts.find_or_initialize_by(person_id: sender.person.id)
contact.sharing = true
contact.save
end
it_behaves_like "messages which are indifferent about sharing fact"
......@@ -104,74 +67,84 @@ describe "Receive federation messages feature" do
end
context "with private receive" do
before do
@public = false
end
let(:recipient) { alice }
it "treats sharing request recive correctly" do
entity = FactoryGirl.build(:request_entity, recipient_id: alice.diaspora_handle)
expect(Diaspora::Fetcher::Public).to receive(:queue_for).exactly(1).times
post_private_message(alice.guid, generate_xml(entity, remote_user_on_pod_b, alice))
post_message(generate_xml(entity, sender, alice), alice)
expect(alice.contacts.count).to eq(2)
new_contact = alice.contacts.order(created_at: :asc).last
expect(new_contact).not_to be_nil
expect(new_contact.sharing).to eq(true)
expect(new_contact.person.diaspora_handle).to eq(remote_user_on_pod_b.diaspora_handle)
expect(new_contact.person.diaspora_handle).to eq(sender_id)
expect(
Notifications::StartedSharing.where(
Notifications::StartedSharing.exists?(
recipient_id: alice.id,
target_type: "Person",
target_id: remote_user_on_pod_b.person.id
).first
).not_to be_nil
target_id: sender.person.id
)
).to be_truthy
end
it "doesn't save the private status message if there is no sharing" do
post_private_message(alice.guid, generate_status_message)
entity = FactoryGirl.build(:status_message_entity, diaspora_id: sender_id, public: false)
post_message(generate_xml(entity, sender, alice), alice)
expect(StatusMessage.exists?(guid: @entity.guid)).to be(false)
expect(StatusMessage.exists?(guid: entity.guid)).to be_falsey
end
context "with sharing" do
before do
set_up_sharing
contact = alice.contacts.find_or_initialize_by(person_id: sender.person.id)
contact.sharing = true
contact.save
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)
entity = FactoryGirl.build(:profile_entity, diaspora_id: sender_id)
post_message(generate_xml(entity, sender, alice), alice)
expect(Profile.where(diaspora_handle: @entity.diaspora_id).exists?).to be(true)
expect(Profile.exists?(diaspora_handle: entity.diaspora_id)).to be_truthy
end
it "receives conversation correctly" do
post_private_message(alice.guid, generate_conversation)
entity = FactoryGirl.build(
:conversation_entity,
diaspora_id: sender_id,
participant_ids: "#{sender_id};#{alice.diaspora_handle}"
)
post_message(generate_xml(entity, sender, alice), alice)
expect(Conversation.exists?(guid: @entity.guid)).to be(true)
expect(Conversation.exists?(guid: entity.guid)).to be_truthy
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
let(:local_target) {
FactoryGirl.build(:conversation, author: alice.person).tap do |target|
target.participants << remote_user_on_pod_b.person
target.participants << remote_user_on_pod_c.person
target.save
end
}
let(:remote_target) {
FactoryGirl.build(:conversation, author: remote_user_on_pod_b.person).tap do |target|
target.participants << alice.person
target.participants << remote_user_on_pod_c.person
target.save
end
}
let(:entity_name) { :message_entity }
let(:klass) { Message }
it_behaves_like "it deals correctly with a relayable"
end
end
end
......
shared_examples_for "it deals correctly with a relayable" do
it "treats upstream receive correctly" do
expect(Postzord::Dispatcher).to receive(:build).with(alice, kind_of(klass)).and_call_original
post_message(alice.guid, generate_relayable_local_parent(entity_name))
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
context "local" do
let(:entity) { create_relayable_entity(entity_name, local_target, sender_id, nil) }
it "rejects an upstream entity with a malformed author signature" do
expect(Postzord::Dispatcher).not_to receive(:build)
post_message(
alice.guid,
generate_relayable_local_parent_wrong_author_key(entity_name)
)
expect(klass.exists?(guid: @entity.guid)).to be(false)
end
it "treats upstream receive correctly" do
expect(Postzord::Dispatcher).to receive(:build).with(alice, kind_of(klass)).and_call_original
post_message(generate_xml(entity, sender, recipient), recipient)
it "treats downstream receive correctly" do
expect(Postzord::Dispatcher).to receive(:build).with(alice, kind_of(klass)).and_call_original unless @public
post_message(alice.guid, generate_relayable_remote_parent(entity_name))
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_c.person.diaspora_handle)
end
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.diaspora_handle)
end
it "rejects a downstream entity with a malformed author signature" do
expect(Postzord::Dispatcher).not_to receive(:build)
post_message(
alice.guid,
generate_relayable_remote_parent_wrong_author_key(entity_name)
)
expect(klass.exists?(guid: @entity.guid)).to be(false)
# 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
expect(Postzord::Dispatcher).not_to receive(:build)
allow(remote_user_on_pod_b).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
post_message(generate_xml(entity, sender, recipient), recipient)
expect(klass.exists?(guid: entity.guid)).to be_falsey
end
end
it "declines downstream receive when sender signed with a wrong key" do
expect(Postzord::Dispatcher).not_to receive(:build)
post_message(
alice.guid,
generate_relayable_remote_parent_wrong_parent_key(entity_name)
)
expect(klass.exists?(guid: @entity.guid)).to be(false)
context "remote" do
let(:author_id) { remote_user_on_pod_c.diaspora_handle }
let(:entity) { create_relayable_entity(entity_name, remote_target, author_id, sender.encryption_key) }
it "treats downstream receive correctly" do
expect(Postzord::Dispatcher).to receive(:build)
.with(alice, kind_of(klass)).and_call_original unless recipient.nil?
post_message(generate_xml(entity, sender, recipient), recipient)
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_c.diaspora_handle)
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
expect(Postzord::Dispatcher).not_to receive(:build)
allow(remote_user_on_pod_c).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
post_message(generate_xml(entity, sender, recipient), recipient)
expect(klass.exists?(guid: entity.guid)).to be_falsey
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
expect(Postzord::Dispatcher).not_to receive(:build)
allow(sender).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
post_message(generate_xml(entity, sender, recipient), recipient)
expect(klass.exists?(guid: entity.guid)).to be_falsey
end
end
end
def retraction_entity(entity_name, target_object, sender)
allow(DiasporaFederation.callbacks).to receive(:trigger)
.with(
:fetch_entity_author_id_by_guid,
target_object.class.to_s,
target_object.guid
)
.and_return(sender.encryption_key)
FactoryGirl.build(
entity_name,
diaspora_id: sender.diaspora_handle,
target_guid: target_object.guid,
target_type: target_object.class.to_s
)
end
shared_examples_for "it retracts non-relayable object" do
it "retracts object by a correct retraction message" do
target_klass = target_object.class.to_s.constantize
post_message(alice.guid, generate_retraction(entity_name, target_object))
entity = retraction_entity(entity_name, target_object, sender)
post_message(generate_xml(entity, sender, recipient), recipient)
expect(target_klass.exists?(guid: target_object.guid)).to be(false)
expect(target_object.class.exists?(guid: target_object.guid)).to be_falsey
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))
allow(sender).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
entity = retraction_entity(entity_name, target_object, sender)
post_message(generate_xml(entity, sender, recipient), recipient)
expect(target_klass.exists?(guid: target_object.guid)).to be(true)
expect(target_object.class.exists?(guid: target_object.guid)).to be_truthy
end
it "doesn't retract object when sender is different from target object" do
target_klass = target_object.class.to_s.constantize
post_message(
alice.guid,
generate_retraction(entity_name, target_object, remote_user_on_pod_c)
)
entity = retraction_entity(entity_name, target_object, remote_user_on_pod_c)
post_message(generate_xml(entity, remote_user_on_pod_c, recipient), recipient)
expect(target_klass.exists?(guid: target_object.guid)).to be(true)
expect(target_object.class.exists?(guid: target_object.guid)).to be_truthy
end
end
shared_examples_for "it retracts relayable object" do
it "retracts object by a correct message" do
target_klass = target_object.class.to_s.constantize
post_message(alice.guid, generate_retraction(entity_name, target_object, sender))
entity = retraction_entity(entity_name, target_object, sender)
post_message(generate_xml(entity, sender, recipient), recipient)
expect(target_klass.exists?(guid: target_object.guid)).to be(false)
expect(target_object.class.exists?(guid: target_object.guid)).to be_falsey
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, sender)
)
allow(sender).to receive(:encryption_key).and_return(OpenSSL::PKey::RSA.new(1024))
entity = retraction_entity(entity_name, target_object, sender)
post_message(generate_xml(entity, sender, recipient), recipient)
expect(target_klass.exists?(guid: target_object.guid)).to be(true)
expect(target_object.class.exists?(guid: target_object.guid)).to be_truthy
end
end
# 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
let(:public) { recipient.nil? }