nocebo/diaspora
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove namespacing from federation libs recently migrated from app/models/

Browse source
This commit is contained in:
Oliver Azevedo Barnes 2013-08-13 18:23:05 -05:00
parent 1c9d65e94c
commit 7214dc184d
22 changed files with 301 additions and 315 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
app/models/contact.rb
View file

@ -61,7 +61,7 @@ class Contact < ActiveRecord::Base
end
def generate_request
Diaspora::Federated::Request.diaspora_initialize(:from => self.user.person,
Request.diaspora_initialize(:from => self.user.person,
:to => self.person,
:into => aspects.first)
end

2
app/models/notification.rb
View file

@ -83,7 +83,7 @@ private
n = notification_type.new(:target => target,
:recipient_id => recipient.id)
n.actors = n.actors | [actor]
n.unread = false if target.is_a? Diaspora::Federated::Request
n.unread = false if target.is_a? Request
n.save!
n
end

6
app/models/user.rb
View file

@ -297,11 +297,11 @@ class User < ActiveRecord::Base
######### Posts and Such ###############
def retract(target, opts={})
if target.respond_to?(:relayable?) && target.relayable?
retraction = Diaspora::Federated::RelayableRetraction.build(self, target)
retraction = RelayableRetraction.build(self, target)
elsif target.is_a? Post
retraction = Diaspora::Federated::SignedRetraction.build(self, target)
retraction = SignedRetraction.build(self, target)
else
retraction = Diaspora::Federated::Retraction.for(target)
retraction = Retraction.for(target)
end
if target.is_a?(Post)

2
app/models/user/connecting.rb
View file

@ -56,7 +56,7 @@ module User::Connecting
def disconnect(bad_contact, opts={})
person = bad_contact.person
Rails.logger.info("event=disconnect user=#{diaspora_handle} target=#{person.diaspora_handle}")
retraction = Diaspora::Federated::Retraction.for(self)
retraction = Retraction.for(self)
retraction.subscribers = [person]#HAX
Postzord::Dispatcher.build(self, retraction).post

2
features/support/paths.rb
View file

@ -22,7 +22,7 @@ module NavigationHelpers
when /^my acceptance form page$/
invite_code_path(InvitationCode.first)
when /^the requestors profile$/
person_path(Diaspora::Federated::Request.where(:recipient_id => @me.person.id).first.sender)
person_path(Request.where(:recipient_id => @me.person.id).first.sender)
when /^"([^\"]*)"'s page$/
person_path(User.find_by_email($1).person)
when /^my account settings page$/

104
lib/diaspora/federated/relayable_retraction.rb
View file

@ -1,67 +1,63 @@
# Copyright (c) 2010-2011, Diaspora Inc. This file is
# licensed under the Affero General Public License version 3 or later. See
# the COPYRIGHT file.
module Diaspora
module Federated
class RelayableRetraction < SignedRetraction
xml_name :relayable_retraction
xml_attr :parent_author_signature
class RelayableRetraction < SignedRetraction
xml_name :relayable_retraction
xml_attr :parent_author_signature
attr_accessor :parent_author_signature
attr_accessor :parent_author_signature
delegate :parent, :parent_author, to: :target, allow_nil: true
delegate :parent, :parent_author, to: :target, allow_nil: true
def signable_accessors
super - ['parent_author_signature']
end
def signable_accessors
super - ['parent_author_signature']
end
# @param sender [User]
# @param target [Object]
def self.build(sender, target)
retraction = super
retraction.parent_author_signature = retraction.sign_with_key(sender.encryption_key) if defined?(target.parent) && sender.person == target.parent.author
retraction
end
# @param sender [User]
# @param target [Object]
def self.build(sender, target)
retraction = super
retraction.parent_author_signature = retraction.sign_with_key(sender.encryption_key) if defined?(target.parent) && sender.person == target.parent.author
retraction
end
def diaspora_handle
self.sender_handle
end
def diaspora_handle
self.sender_handle
end
def relayable?
true
end
def relayable?
true
end
def perform receiving_user
Rails.logger.debug "Performing relayable retraction for #{target_guid}"
if not self.parent_author_signature.nil? or self.parent.author.remote?
# Don't destroy a relayable unless the top-level owner has received it, otherwise it may not get relayed
self.target.destroy
Rails.logger.info("event=relayable_retraction status =complete target_type=#{self.target_type} guid =#{self.target_guid}")
end
end
def receive(recipient, sender)
if self.target.nil?
Rails.logger.info("event=retraction status=abort reason='no post found' sender=#{sender.diaspora_handle} target_guid=#{target_guid}")
return
elsif self.parent.author == recipient.person && self.target_author_signature_valid?
#this is a retraction from the downstream object creator, and the recipient is the upstream owner
self.parent_author_signature = self.sign_with_key(recipient.encryption_key)
Postzord::Dispatcher.build(recipient, self).post
self.perform(recipient)
elsif self.parent_author_signature_valid?
#this is a retraction from the upstream owner
self.perform(recipient)
else
Rails.logger.info("event=receive status=abort reason='object signature not valid' recipient=#{recipient.diaspora_handle} sender=#{self.parent.author.diaspora_handle} payload_type=#{self.class} parent_id=#{self.parent.id}")
return
end
self
end
def parent_author_signature_valid?
verify_signature(self.parent_author_signature, self.parent.author)
end
def perform receiving_user
Rails.logger.debug "Performing relayable retraction for #{target_guid}"
if not self.parent_author_signature.nil? or self.parent.author.remote?
# Don't destroy a relayable unless the top-level owner has received it, otherwise it may not get relayed
self.target.destroy
Rails.logger.info("event=relayable_retraction status =complete target_type=#{self.target_type} guid =#{self.target_guid}")
end
end
def receive(recipient, sender)
if self.target.nil?
Rails.logger.info("event=retraction status=abort reason='no post found' sender=#{sender.diaspora_handle} target_guid=#{target_guid}")
return
elsif self.parent.author == recipient.person && self.target_author_signature_valid?
#this is a retraction from the downstream object creator, and the recipient is the upstream owner
self.parent_author_signature = self.sign_with_key(recipient.encryption_key)
Postzord::Dispatcher.build(recipient, self).post
self.perform(recipient)
elsif self.parent_author_signature_valid?
#this is a retraction from the upstream owner
self.perform(recipient)
else
Rails.logger.info("event=receive status=abort reason='object signature not valid' recipient=#{recipient.diaspora_handle} sender=#{self.parent.author.diaspora_handle} payload_type=#{self.class} parent_id=#{self.parent.id}")
return
end
self
end
def parent_author_signature_valid?
verify_signature(self.parent_author_signature, self.parent.author)
end
end

159
lib/diaspora/federated/request.rb
View file

@ -2,104 +2,101 @@
# t
# licensed under the Affero General Public License version 3 or later. See
# the COPYRIGHT file.
module Diaspora
module Federated
class Request
include Base
include ActiveModel::Validations
attr_accessor :sender, :recipient, :aspect
class Request
include Diaspora::Federated::Base
include ActiveModel::Validations
xml_accessor :sender_handle
xml_accessor :recipient_handle
attr_accessor :sender, :recipient, :aspect
validates :sender, :presence => true
validates :recipient, :presence => true
xml_accessor :sender_handle
xml_accessor :recipient_handle
validate :not_already_connected
validate :not_friending_yourself
validates :sender, :presence => true
validates :recipient, :presence => true
# Initalize variables
# @note we should be using ActiveModel::Serialization for this
# @return [Request]
def self.diaspora_initialize(opts = {})
req = self.new
req.sender = opts[:from]
req.recipient = opts[:to]
req.aspect = opts[:into]
req
end
validate :not_already_connected
validate :not_friending_yourself
# Alias of sender_handle
# @return [String]
def diaspora_handle
sender_handle
end
# Initalize variables
# @note we should be using ActiveModel::Serialization for this
# @return [Request]
def self.diaspora_initialize(opts = {})
req = self.new
req.sender = opts[:from]
req.recipient = opts[:to]
req.aspect = opts[:into]
req
end
# @note Used for XML marshalling
# @return [String]
def sender_handle
sender.diaspora_handle
end
def sender_handle= sender_handle
self.sender = Person.where(:diaspora_handle => sender_handle).first
end
# Alias of sender_handle
# @return [String]
def diaspora_handle
sender_handle
end
# @note Used for XML marshalling
# @return [String]
def recipient_handle
recipient.diaspora_handle
end
def recipient_handle= recipient_handle
self.recipient = Person.where(:diaspora_handle => recipient_handle).first
end
# @note Used for XML marshalling
# @return [String]
def sender_handle
sender.diaspora_handle
end
def sender_handle= sender_handle
self.sender = Person.where(:diaspora_handle => sender_handle).first
end
# Defines the abstract interface used in sending a corresponding [Notification] given the [Request]
# @param user [User]
# @param person [Person]
# @return [Notifications::StartedSharing]
def notification_type(user, person)
Notifications::StartedSharing
end
# @note Used for XML marshalling
# @return [String]
def recipient_handle
recipient.diaspora_handle
end
def recipient_handle= recipient_handle
self.recipient = Person.where(:diaspora_handle => recipient_handle).first
end
# Defines the abstract interface used in sending the [Request]
# @param user [User]
# @return [Array<Person>] The recipient of the request
def subscribers(user)
[self.recipient]
end
# Defines the abstract interface used in sending a corresponding [Notification] given the [Request]
# @param user [User]
# @param person [Person]
# @return [Notifications::StartedSharing]
def notification_type(user, person)
Notifications::StartedSharing
end
# Finds or initializes a corresponding [Contact], and will set Contact#sharing to true
# Follows back if user setting is set so
# @note A [Contact] may already exist if the [Request]'s recipient is sharing with the sender
# @return [Request]
def receive(user, person)
Rails.logger.info("event=receive payload_type=request sender=#{self.sender} to=#{self.recipient}")
# Defines the abstract interface used in sending the [Request]
# @param user [User]
# @return [Array<Person>] The recipient of the request
def subscribers(user)
[self.recipient]
end
contact = user.contacts.find_or_initialize_by_person_id(self.sender.id)
contact.sharing = true
contact.save
# Finds or initializes a corresponding [Contact], and will set Contact#sharing to true
# Follows back if user setting is set so
# @note A [Contact] may already exist if the [Request]'s recipient is sharing with the sender
# @return [Request]
def receive(user, person)
Rails.logger.info("event=receive payload_type=request sender=#{self.sender} to=#{self.recipient}")
user.share_with(person, user.auto_follow_back_aspect) if user.auto_follow_back && !contact.receiving
contact = user.contacts.find_or_initialize_by_person_id(self.sender.id)
contact.sharing = true
contact.save
self
end
user.share_with(person, user.auto_follow_back_aspect) if user.auto_follow_back && !contact.receiving
private
self
end
# Checks if a [Contact] does not already exist between the requesting [User] and receiving [Person]
def not_already_connected
if sender && recipient && Contact.where(:user_id => self.recipient.owner_id, :person_id => self.sender.id).exists?
errors[:base] << 'You have already connected to this person'
end
end
private
# Checks to see that the requesting [User] is not sending a request to himself
def not_friending_yourself
if self.recipient == self.sender
errors[:base] << 'You can not friend yourself'
end
end
# Checks if a [Contact] does not already exist between the requesting [User] and receiving [Person]
def not_already_connected
if sender && recipient && Contact.where(:user_id => self.recipient.owner_id, :person_id => self.sender.id).exists?
errors[:base] << 'You have already connected to this person'
end
end
# Checks to see that the requesting [User] is not sending a request to himself
def not_friending_yourself
if self.recipient == self.sender
errors[:base] << 'You can not friend yourself'
end
end
end

112
lib/diaspora/federated/retraction.rb
View file

@ -1,67 +1,63 @@
# Copyright (c) 2010-2011, Diaspora Inc. This file is
# licensed under the Affero General Public License version 3 or later. See
# the COPYRIGHT file.
module Diaspora
module Federated
class Retraction
include Base
class Retraction
include Diaspora::Federated::Base
xml_accessor :post_guid
xml_accessor :diaspora_handle
xml_accessor :type
xml_accessor :post_guid
xml_accessor :diaspora_handle
xml_accessor :type
attr_accessor :person, :object, :subscribers
attr_accessor :person, :object, :subscribers
def subscribers(user)
unless self.type == 'Person'
@subscribers ||= self.object.subscribers(user)
@subscribers -= self.object.resharers unless self.object.is_a?(Photo)
@subscribers
else
raise 'HAX: you must set the subscribers manaully before unfriending' if @subscribers.nil?
@subscribers
end
end
def self.for(object)
retraction = self.new
if object.is_a? User
retraction.post_guid = object.person.guid
retraction.type = object.person.class.to_s
else
retraction.post_guid = object.guid
retraction.type = object.class.to_s
retraction.object = object
end
retraction.diaspora_handle = object.diaspora_handle
retraction
end
def target
@target ||= self.type.constantize.where(:guid => post_guid).first
end
def perform receiving_user
Rails.logger.debug "Performing retraction for #{post_guid}"
self.target.destroy if self.target
Rails.logger.info("event=retraction status=complete type=#{self.type} guid=#{self.post_guid}")
end
def receive(user, person)
if self.type == 'Person'
unless self.person.guid.to_s == self.post_guid.to_s
Rails.logger.info("event=receive status=abort reason='sender is not the person he is trying to retract' recipient=#{self.diaspora_handle} sender=#{self.person.diaspora_handle} payload_type=#{self.class} retraction_type=person")
return
end
user.disconnected_by(self.target)
elsif self.target.nil? || self.target.author != self.person
Rails.logger.info("event=retraction status=abort reason='no post found authored by retractor' sender=#{person.diaspora_handle} post_guid=#{post_guid}")
else
self.perform(user)
end
self
end
def subscribers(user)
unless self.type == 'Person'
@subscribers ||= self.object.subscribers(user)
@subscribers -= self.object.resharers unless self.object.is_a?(Photo)
@subscribers
else
raise 'HAX: you must set the subscribers manaully before unfriending' if @subscribers.nil?
@subscribers
end
end
def self.for(object)
retraction = self.new
if object.is_a? User
retraction.post_guid = object.person.guid
retraction.type = object.person.class.to_s
else
retraction.post_guid = object.guid
retraction.type = object.class.to_s
retraction.object = object
end
retraction.diaspora_handle = object.diaspora_handle
retraction
end
def target
@target ||= self.type.constantize.where(:guid => post_guid).first
end
def perform receiving_user
Rails.logger.debug "Performing retraction for #{post_guid}"
self.target.destroy if self.target
Rails.logger.info("event=retraction status=complete type=#{self.type} guid=#{self.post_guid}")
end
def receive(user, person)
if self.type == 'Person'
unless self.person.guid.to_s == self.post_guid.to_s
Rails.logger.info("event=receive status=abort reason='sender is not the person he is trying to retract' recipient=#{self.diaspora_handle} sender=#{self.person.diaspora_handle} payload_type=#{self.class} retraction_type=person")
return
end
user.disconnected_by(self.target)
elsif self.target.nil? || self.target.author != self.person
Rails.logger.info("event=retraction status=abort reason='no post found authored by retractor' sender=#{person.diaspora_handle} post_guid=#{post_guid}")
else
self.perform(user)
end
self
end
end

189
lib/diaspora/federated/signed_retraction.rb
View file

@ -1,108 +1,105 @@
# Copyright (c) 2010-2011, Diaspora Inc. This file is
# licensed under the Affero General Public License version 3 or later. See
# the COPYRIGHT file.
module Diaspora
module Federated
class SignedRetraction
include Base
include Diaspora::Encryptable
class SignedRetraction
include Diaspora::Federated::Base
xml_name :signed_retraction
xml_attr :target_guid
xml_attr :target_type
xml_attr :sender_handle
xml_attr :target_author_signature
include Diaspora::Encryptable
attr_accessor :target_guid,
:target_type,
:target_author_signature,
:sender
xml_name :signed_retraction
xml_attr :target_guid
xml_attr :target_type
xml_attr :sender_handle
xml_attr :target_author_signature
#NOTE(fix this hack -- go through the app and make sure we only call RelayableRetraction in a unified way)
def author
if sender.is_a?(User)
sender.person
else
sender
end
end
attr_accessor :target_guid,
:target_type,
:target_author_signature,
:sender
def signable_accessors
accessors = self.class.roxml_attrs.collect do |definition|
definition.accessor
end
accessors - ['target_author_signature', 'sender_handle']
end
def sender_handle= new_sender_handle
@sender = Person.where(:diaspora_handle => new_sender_handle).first
end
def sender_handle
@sender.diaspora_handle
end
def diaspora_handle
self.sender_handle
end
def subscribers(user)
self.target.subscribers(user)
end
def self.build(sender, target)
retraction = self.new
retraction.sender = sender
retraction.target = target
retraction.target_author_signature = retraction.sign_with_key(sender.encryption_key) if sender.person == target.author
retraction
end
def target
@target ||= self.target_type.constantize.where(:guid => target_guid).first
end
def guid
target_guid
end
def target= new_target
@target = new_target
@target_type = new_target.class.to_s
@target_guid = new_target.guid
end
def perform receiving_user
Rails.logger.debug "Performing retraction for #{target_guid}"
if reshare = Reshare.where(:author_id => receiving_user.person.id, :root_guid => target_guid).first
onward_retraction = self.dup
onward_retraction.sender = receiving_user.person
Postzord::Dispatcher.build(receiving_user, onward_retraction).post
end
if target
self.target.destroy
end
Rails.logger.info("event=retraction status =complete target_type=#{self.target_type} guid =#{self.target_guid}")
end
def receive(recipient, sender)
if self.target.nil?
Rails.logger.info("event=retraction status=abort reason='no post found' sender=#{sender.diaspora_handle} target_guid=#{target_guid}")
return
elsif self.target_author_signature_valid?
#this is a retraction from the upstream owner
self.perform(recipient)
else
Rails.logger.info("event=receive status=abort reason='object signature not valid' recipient=#{recipient.diaspora_handle} sender=#{self.sender_handle} payload_type=#{self.class}")
return
end
self
end
def target_author_signature_valid?
verify_signature(self.target_author_signature, self.target.author)
end
#NOTE(fix this hack -- go through the app and make sure we only call RelayableRetraction in a unified way)
def author
if sender.is_a?(User)
sender.person
else
sender
end
end
def signable_accessors
accessors = self.class.roxml_attrs.collect do |definition|
definition.accessor
end
accessors - ['target_author_signature', 'sender_handle']
end
def sender_handle= new_sender_handle
@sender = Person.where(:diaspora_handle => new_sender_handle).first
end
def sender_handle
@sender.diaspora_handle
end
def diaspora_handle
self.sender_handle
end
def subscribers(user)
self.target.subscribers(user)
end
def self.build(sender, target)
retraction = self.new
retraction.sender = sender
retraction.target = target
retraction.target_author_signature = retraction.sign_with_key(sender.encryption_key) if sender.person == target.author
retraction
end
def target
@target ||= self.target_type.constantize.where(:guid => target_guid).first
end
def guid
target_guid
end
def target= new_target
@target = new_target
@target_type = new_target.class.to_s
@target_guid = new_target.guid
end
def perform receiving_user
Rails.logger.debug "Performing retraction for #{target_guid}"
if reshare = Reshare.where(:author_id => receiving_user.person.id, :root_guid => target_guid).first
onward_retraction = self.dup
onward_retraction.sender = receiving_user.person
Postzord::Dispatcher.build(receiving_user, onward_retraction).post
end
if target
self.target.destroy
end
Rails.logger.info("event=retraction status =complete target_type=#{self.target_type} guid =#{self.target_guid}")
end
def receive(recipient, sender)
if self.target.nil?
Rails.logger.info("event=retraction status=abort reason='no post found' sender=#{sender.diaspora_handle} target_guid=#{target_guid}")
return
elsif self.target_author_signature_valid?
#this is a retraction from the upstream owner
self.perform(recipient)
else
Rails.logger.info("event=receive status=abort reason='object signature not valid' recipient=#{recipient.diaspora_handle} sender=#{self.sender_handle} payload_type=#{self.class}")
return
end
self
end
def target_author_signature_valid?
verify_signature(self.target_author_signature, self.target.author)
end
end

2
lib/postzord/dispatcher.rb
View file

@ -149,7 +149,7 @@ class Postzord::Dispatcher
if @object.instance_of?(StatusMessage)
Workers::PostToService.perform_async(service.id, @object.id, url)
end
if @object.instance_of?(Diaspora::Federated::SignedRetraction)
if @object.instance_of?(SignedRetraction)
Workers::DeletePostFromService.perform_async(service.id, @object.target.id)
end
end

4
lib/postzord/receiver/private.rb
View file

@ -99,7 +99,7 @@ class Postzord::Receiver::Private < Postzord::Receiver
end
def contact_required_unless_request
unless @object.is_a?(Diaspora::Federated::Request) || @user.contact_for(@sender)
unless @object.is_a?(Request) || @user.contact_for(@sender)
FEDERATION_LOGGER.error("event=receive status=abort reason='sender not connected to recipient' recipient=#{@user_person.diaspora_handle} sender=#{@sender.diaspora_handle}")
return true
end
@ -107,7 +107,7 @@ class Postzord::Receiver::Private < Postzord::Receiver
def assign_sender_handle_if_request
#special casey
if @object.is_a?(Diaspora::Federated::Request)
if @object.is_a?(Request)
@object.sender_handle = @sender.diaspora_handle
end
end

2
lib/postzord/receiver/public.rb
View file

@ -30,7 +30,7 @@ class Postzord::Receiver::Public < Postzord::Receiver
receive_relayable
elsif @object.is_a?(AccountDeletion)
#nothing
elsif @object.is_a?(Diaspora::Federated::SignedRetraction) # feels like a hack
elsif @object.is_a?(SignedRetraction) # feels like a hack
self.recipient_user_ids.each do |user_id|
user = User.where(id: user_id).first
@object.perform user if user

2
spec/integration/attack_vectors_spec.rb
View file

@ -47,7 +47,7 @@ def expect_error(partial_message, &block)# DOES NOT REQUIRE ERROR!!
end
def bogus_retraction(&block)
ret = Diaspora::Federated::Retraction.new
ret = Retraction.new
yield ret
ret
end

6
spec/integration/receiving_spec.rb
View file

@ -317,7 +317,7 @@ describe 'a user receives a post' do
let(:zord) { Postzord::Receiver::Private.new(alice, person: bob.person) }
it 'should accept retractions' do
retraction = Diaspora::Federated::Retraction.for(message)
retraction = Retraction.for(message)
xml = retraction.to_diaspora_xml
expect {
@ -327,7 +327,7 @@ describe 'a user receives a post' do
it 'should accept relayable retractions' do
comment = bob.comment! message, "and dogs"
retraction = Diaspora::Federated::RelayableRetraction.build(bob, comment)
retraction = RelayableRetraction.build(bob, comment)
xml = retraction.to_diaspora_xml
expect {
@ -337,7 +337,7 @@ describe 'a user receives a post' do
it 'should accept signed retractions for public posts' do
message = bob.post(:status_message, text: "cats", public: true)
retraction = Diaspora::Federated::SignedRetraction.build(bob, message)
retraction = SignedRetraction.build(bob, message)
salmon = Postzord::Dispatcher::Public.salmon bob, retraction.to_diaspora_xml
xml = salmon.xml_for alice.person
zord = Postzord::Receiver::Public.new xml

2
spec/lib/diaspora/federated/relayable_retraction_spec.rb
View file

@ -6,7 +6,7 @@ require 'spec_helper'
require Rails.root.join("spec", "shared_behaviors", "relayable")
# require Rails.root.join('lib', 'diaspora', 'federated', 'messages')
describe Diaspora::Federated::RelayableRetraction do
describe RelayableRetraction do
before do
@local_luke, @local_leia, @remote_raphael = set_up_friends
@remote_parent = FactoryGirl.build(:status_message, :author => @remote_raphael)

2
spec/lib/diaspora/federated/request_spec.rb
View file

@ -4,7 +4,7 @@
require 'spec_helper'
describe Diaspora::Federated::Request do
describe Request do
before do
@aspect = alice.aspects.first
end

2
spec/lib/diaspora/federated/retraction_spec.rb
View file

@ -5,7 +5,7 @@
require 'spec_helper'
# require Rails.root.join('lib', 'diaspora', 'federated', 'messages')
describe Diaspora::Federated::Retraction do
describe Retraction do
before do
@aspect = alice.aspects.first
alice.contacts.create(:person => eve.person, :aspects => [@aspect])

2
spec/lib/diaspora/federated/signed_retraction_spec.rb
View file

@ -1,7 +1,7 @@
require 'spec_helper'
# require Rails.root.join('lib', 'diaspora', 'federated', 'messages')
describe Diaspora::Federated::SignedRetraction do
describe SignedRetraction do
before do
@post = FactoryGirl.create(:status_message, :author => bob.person, :public => true)
@resharer = FactoryGirl.create(:user)

4
spec/lib/postzord/dispatcher_spec.rb
View file

@ -262,7 +262,7 @@ describe Postzord::Dispatcher do
end
it 'returns false for a relayable_retraction' do
f = Diaspora::Federated::RelayableRetraction.new
f = RelayableRetraction.new
f.target = FactoryGirl.create(:status_message, :public => true)
Postzord::Dispatcher.object_should_be_processed_as_public?(f).should be_false
end
@ -312,7 +312,7 @@ describe Postzord::Dispatcher do
end
it 'queues a job to delete if given retraction' do
retraction = Diaspora::Federated::SignedRetraction.build(alice, FactoryGirl.create(:status_message))
retraction = SignedRetraction.build(alice, FactoryGirl.create(:status_message))
mailman = Postzord::Dispatcher.build(alice, retraction, :url => "http://joindiaspora.com/p/123", :services => [@service])
Workers::DeletePostFromService.should_receive(:perform_async).with(anything, anything)

2
spec/models/notification_spec.rb
View file

@ -65,7 +65,7 @@ describe Notification do
describe '.notify' do
context 'with a request' do
before do
@request = Diaspora::Federated::Request.diaspora_initialize(:from => @user.person, :to => @user2.person, :into => @aspect)
@request = Request.diaspora_initialize(:from => @user.person, :to => @user2.person, :into => @aspect)
end
it 'calls Notification.create if the object has a notification_type' do

2
spec/models/user_spec.rb
View file

@ -800,7 +800,7 @@ describe User do
context "posts" do
before do
Diaspora::Federated::SignedRetraction.stub(:build).and_return(@retraction)
SignedRetraction.stub(:build).and_return(@retraction)
@retraction.stub(:perform)
end

2
spec/shared_behaviors/relayable.rb
View file

@ -34,7 +34,7 @@ describe Diaspora::Relayable do
it "sends a retraction for the object" do
pending 'need to figure out how to test this'
Diaspora::Federated::RelayableRetraction.should_receive(:build)
RelayableRetraction.should_receive(:build)
Postzord::Dispatcher.should_receive(:build)
@relayable.valid?
end