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

Merge branch 'master' of github.com:diaspora/diaspora

Browse source
This commit is contained in:
danielvincent 2010-10-20 12:19:24 -07:00
commit 65ffe2ecdd
19 changed files with 347 additions and 170 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
app/controllers/registrations_controller.rb
View file

@ -4,15 +4,10 @@
class RegistrationsController < Devise::RegistrationsController
def create
begin
@user = User.instantiate!(params[:user])
rescue MongoMapper::DocumentNotValid => e
flash[:error] = e.message
redirect_to new_user_registration_path
return
end
@user = User.build(params[:user])
if @user.save
flash[:notice] = I18n.t 'registrations.create.success'
@user.seed_aspects
sign_in_and_redirect(:user, @user)
else
flash[:error] = @user.errors.full_messages.join(', ')

11
app/controllers/requests_controller.rb
View file

@ -35,8 +35,15 @@ class RequestsController < ApplicationController
begin
rel_hash = relationship_flow(params[:request][:destination_url].strip)
rescue Exception => e
raise e unless e.message.include? "not found"
flash[:error] = I18n.t 'requests.create.error'
if e.message.include? "not found"
flash[:error] = I18n.t 'requests.create.error'
elsif e.message.include? "Connection timed out"
flash[:error] = I18n.t 'requests.create.error_server'
elsif e.message == "Identifier is invalid"
flash[:error] = I18n.t 'requests.create.invalid_identity'
else
raise e
end
respond_with :location => aspect
return
end

6
app/models/person.rb
View file

@ -92,7 +92,11 @@ class Person
end
def self.by_webfinger(identifier, opts = {})
#need to check if this is a valid email structure, maybe should do in JS
# Raise an error if identifier has a port number
raise "Identifier is invalid" if(identifier.strip.match(/\:\d+$/))
# Raise an error if identifier is not a valid email (generous regexp)
raise "Identifier is invalid" if !(identifier =~ /\A.*\@.*\..*\Z/)
query = /#{Regexp.escape(identifier.gsub('acct:', '').to_s)}/i
local_person = Person.first(:diaspora_handle => query)

40
app/models/user.rb
View file

@ -106,24 +106,36 @@ class User
def move_friend(opts = {})
return true if opts[:to] == opts[:from]
friend = Person.first(:_id => opts[:friend_id])
if self.friend_ids.include?(friend.id)
from_aspect = self.aspect_by_id(opts[:from])
to_aspect = self.aspect_by_id(opts[:to])
if from_aspect && to_aspect
posts_to_move = from_aspect.posts.find_all_by_person_id(friend.id)
to_aspect.people << friend
to_aspect.posts << posts_to_move
from_aspect.person_ids.delete(friend.id.to_id)
posts_to_move.each { |x| from_aspect.post_ids.delete(x.id) }
from_aspect.save
to_aspect.save
if opts[:friend_id] && opts[:to] && opts[:from]
from_aspect = self.aspects.first(:_id => opts[:from])
posts_to_move = from_aspect.posts.find_all_by_person_id(opts[:friend_id])
if add_person_to_aspect(opts[:friend_id], opts[:to], :posts => posts_to_move)
delete_person_from_aspect(opts[:friend_id], opts[:from], :posts => posts_to_move)
return true
end
end
false
end
def add_person_to_aspect(person_id, aspect_id, opts = {})
raise "Can not add person to an aspect you do not own" unless aspect = self.aspects.find_by_id(aspect_id)
raise "Can not add person you are not friends with" unless person = self.find_friend_by_id(person_id)
raise 'Can not add person who is already in the aspect' if aspect.person_ids.include?(person_id)
aspect.people << person
opts[:posts] ||= self.raw_visible_posts.all(:person_id => person_id)
aspect.posts += opts[:posts]
aspect.save
end
def delete_person_from_aspect(person_id, aspect_id, opts = {})
raise "Can not delete a person from an aspect you do not own" unless aspect = self.aspects.find_by_id(aspect_id)
aspect.person_ids.delete(person_id)
opts[:posts] ||= aspect.posts.all(:person_id => person_id)
aspect.posts -= opts[:posts]
aspect.save
end
######## Posting ########
def post(class_name, options = {})
if class_name == :photo
@ -379,7 +391,7 @@ class User
end
###Helpers############
def self.instantiate!(opts = {})
def self.build(opts = {})
opts[:person][:diaspora_handle] = "#{opts[:username]}@#{APP_CONFIG[:terse_pod_url]}"
opts[:person][:url] = APP_CONFIG[:pod_url]
@ -387,8 +399,6 @@ class User
opts[:person][:serialized_public_key] = opts[:serialized_private_key].public_key
u = User.new(opts)
u.seed_aspects
u.save!
u
end

2
config/locales/diaspora/en.yml
View file

@ -229,6 +229,8 @@ en:
ignore: "Ignored friend request."
create:
error: "No diaspora seed found with this email!"
invalid_identity: "This identity is not properly formatted"
error_server: "Problem with other server. Maybe it doesn't exist?"
yourself: "You cannot befriend yourself!"
already_friends: "You are already friends with %{destination_url}!"
success: "A friend request was sent to %{destination_url}."

4
db/seeds/backer.rb
View file

@ -25,14 +25,14 @@ def create
require File.join(File.dirname(__FILE__), "..", "..", "config", "initializers", "_load_app_config.rb")
# Create seed user
user = User.instantiate!(:email => "#{username}@#{username}.joindiaspora.com",
user = User.build(:email => "#{username}@#{username}.joindiaspora.com",
:username => username,
:password => "#{username+backer_info[backer_number]['pin'].to_s}",
:password_confirmation => "#{username+backer_info[backer_number]['pin'].to_s}",
:person => Person.new(
:profile => Profile.new( :first_name => backer_info[backer_number]['given_name'], :last_name => backer_info[backer_number]['family_name'],
:image_url => "http://#{username}.joindiaspora.com/images/user/#{username}.jpg")
))
)).save
user.person.save!
user.aspect(:name => "Presidents")

10
db/seeds/dev.rb
View file

@ -18,23 +18,25 @@ username = "tom"
set_app_config username
# Create seed user
user = User.instantiate!( :email => "tom@tom.joindiaspora.com",
user = User.build( :email => "tom@tom.joindiaspora.com",
:username => "tom",
:password => "evankorth",
:password_confirmation => "evankorth",
:person => Person.new(
:profile => Profile.new( :first_name => "Alexander", :last_name => "Hamiltom" ))
)
).save
user.person.save!
user.seed_aspects
user2 = User.instantiate!( :email => "korth@tom.joindiaspora.com",
user2 = User.build( :email => "korth@tom.joindiaspora.com",
:username => "korth",
:password => "evankorth",
:password_confirmation => "evankorth",
:person => Person.new(
:profile => Profile.new( :first_name => "Evan", :last_name => "Korth")))
:profile => Profile.new( :first_name => "Evan", :last_name => "Korth"))).save
user2.person.save!
user2.seed_aspects
# friending users
aspect = user.aspect(:name => "other dudes")

9
db/seeds/tom.rb
View file

@ -18,23 +18,24 @@ set_app_config "tom"
require 'config/initializers/_load_app_config.rb'
# Create seed user
user = User.instantiate!( :email => "tom@tom.joindiaspora.com",
user = User.build( :email => "tom@tom.joindiaspora.com",
:username => "tom",
:password => "evankorth",
:password_confirmation => "evankorth",
:person => {
:profile => { :first_name => "Alexander", :last_name => "Hamiltom",
:image_url => "http://tom.joindiaspora.com/images/user/tom.jpg"}}
)
).save!
user.seed_aspects
user.person.save!
user2 = User.instantiate!( :email => "korth@tom.joindiaspora.com",
user2 = User.build( :email => "korth@tom.joindiaspora.com",
:password => "evankorth",
:password_confirmation => "evankorth",
:username => "korth",
:person => {:profile => { :first_name => "Evan", :last_name => "Korth",
:image_url => "http://tom.joindiaspora.com/images/user/korth.jpg"}})
user2.seed_aspects
user2.person.save!
# friending users

5
lib/diaspora/user/friending.rb
View file

@ -89,7 +89,10 @@ module Diaspora
def remove_friend(bad_friend)
raise "Friend not deleted" unless self.friend_ids.delete( bad_friend.id )
aspects.each{|aspect|
aspect.person_ids.delete( bad_friend.id )}
if aspect.person_ids.delete( bad_friend.id )
aspect.posts.delete_if { |post|
post.person_id == bad_friend.id}
end}
self.save
self.raw_visible_posts.find_all_by_person_id( bad_friend.id ).each{|post|

5
lib/diaspora/user/querying.rb
View file

@ -34,6 +34,11 @@ module Diaspora
aspects.detect{|x| x.id == id }
end
def find_friend_by_id(id)
id = id.to_id
friends.detect{|x| x.id == id }
end
def aspects_with_post( id )
self.aspects.find_all_by_post_ids( id.to_id )
end

4
spec/controllers/registrations_controller_spec.rb
View file

@ -48,7 +48,6 @@ describe RegistrationsController do
lambda { get :create, @invalid_params }.should_not change(User, :count)
end
it "assigns @user" do
pending "GAAAH stupid mongo mapper. Figure out why it thinks it's persisted when validations fail"
get :create, @valid_params
assigns(:user).should_not be_nil
end
@ -57,9 +56,8 @@ describe RegistrationsController do
flash[:error].should_not be_blank
end
it "goes back to the form" do
pending "GAAAH stupid mongo mapper. Figure out why it thinks it's persisted when validations fail"
get :create, @invalid_params
response.should be_success
response.should be_redirect
end
end
end

30
spec/controllers/requests_controller_spec.rb
View file

@ -22,4 +22,34 @@ describe RequestsController do
response.should redirect_to aspect_path(@user.aspects[0].id.to_s)
end
it "should not error out when requesting an invalid identity" do
put("create", "request" => {
"destination_url" => "not_a_@valid_email",
"aspect_id" => @user.aspects[0].id
}
)
response.should redirect_to aspect_path(@user.aspects[0].id.to_s)
end
it "should not error out when requesting an invalid identity with a port number" do
put("create", "request" => {
"destination_url" => "johndoe@email.com:3000",
"aspect_id" => @user.aspects[0].id
}
)
response.should redirect_to aspect_path(@user.aspects[0].id.to_s)
end
it "should not error out when requesting an identity from an invalid server" do
stub_request(:get, /notadiasporaserver\.com/).to_raise(Errno::ETIMEDOUT)
put("create", "request" => {
"destination_url" => "johndoe@notadiasporaserver.com",
"aspect_id" => @user.aspects[0].id
}
)
response.should redirect_to aspect_path(@user.aspects[0].id.to_s)
end
end

17
spec/controllers/users_controller_spec.rb
View file

@ -24,17 +24,26 @@ describe UsersController do
before do
@user.person.profile.image_url = "http://tom.joindiaspora.com/images/user/tom.jpg"
@user.person.profile.save
@params = {"profile"=>
{"image_url" => "",
"last_name" => @user.person.profile.last_name,
"first_name" => @user.person.profile.first_name}}
end
it "doesn't overwrite the profile photo when an empty string is passed in" do
image_url = @user.person.profile.image_url
put("update", :id => @user.id, "user"=> {"profile"=>
{"image_url" => "",
"last_name" => @user.person.profile.last_name,
"first_name" => @user.person.profile.first_name}})
put("update", :id => @user.id, "user" => @params)
@user.person.profile.image_url.should == image_url
end
it "doesn't overwrite random attributes" do
new_user = Factory.create(:user)
@params[:owner_id] = new_user.id
person = @user.person
put('update', :id => @user.id, "user" => @params)
Person.find(person.id).owner_id.should == @user.id
end
end
context 'should allow the user to update their password' do

2
spec/lib/diaspora_parser_spec.rb
View file

@ -153,7 +153,7 @@ describe Diaspora::Parser do
person.save
#Cache profile for checking against marshaled profile
old_profile = person.profile
old_profile = person.profile.dup
old_profile.first_name.should == 'bob'
#Build xml for profile, clear profile

261
spec/models/aspect_spec.rb
View file

@ -5,123 +5,129 @@
require 'spec_helper'
describe Aspect do
before do
@user = Factory.create(:user)
@friend = Factory.create(:person)
@user2 = Factory.create(:user)
@friend_2 = Factory.create(:person)
end
let(:user ) { Factory.create(:user) }
let(:friend) { Factory.create(:person) }
let(:user2) { Factory.create(:user) }
let(:friend_2) { Factory.create(:person) }
let(:aspect) {user.aspect(:name => 'losers')}
let(:aspect2) {user2.aspect(:name => 'failures')}
let(:aspect1) {user.aspect(:name => 'cats')}
let(:not_friend) { Factory(:person, :diaspora_handle => "not@person.com")}
let(:user3) {Factory(:user)}
let(:aspect3) {user3.aspect(:name => "lala")}
describe 'creation' do
it 'should have a name' do
aspect = @user.aspect(:name => 'losers')
aspect = user.aspect(:name => 'losers')
aspect.name.should == "losers"
end
it 'should be creatable with people' do
aspect = @user.aspect(:name => 'losers', :people => [@friend, @friend_2])
aspect = user.aspect(:name => 'losers', :people => [friend, friend_2])
aspect.people.size.should == 2
end
it 'should be able to have other users' do
aspect = @user.aspect(:name => 'losers', :people => [@user2.person])
aspect.people.include?(@user.person).should be false
aspect.people.include?(@user2.person).should be true
aspect = user.aspect(:name => 'losers', :people => [user2.person])
aspect.people.include?(user.person).should be false
aspect.people.include?(user2.person).should be true
aspect.people.size.should == 1
end
it 'should be able to have users and people' do
aspect = @user.aspect(:name => 'losers', :people => [@user2.person, @friend_2])
aspect.people.include?(@user.person).should be false
aspect.people.include?(@user2.person).should be true
aspect.people.include?(@friend_2).should be true
aspect = user.aspect(:name => 'losers', :people => [user2.person, friend_2])
aspect.people.include?(user.person).should be false
aspect.people.include?(user2.person).should be true
aspect.people.include?(friend_2).should be true
aspect.people.size.should == 2
end
end
describe 'validation' do
before do
@aspect = @user.aspect(:name => 'losers')
aspect
end
it 'has a unique name for one user' do
aspect2 = @user.aspect(:name => @aspect.name)
aspect2 = user.aspect(:name => aspect.name)
aspect2.valid?.should be_false
end
it 'has no uniqueness between users' do
aspect2 = @user2.aspect(:name => @aspect.name)
aspect2 = user2.aspect(:name => aspect.name)
aspect2.valid?.should be_true
end
end
describe 'querying' do
before do
@aspect = @user.aspect(:name => 'losers')
@user.activate_friend(@friend, @aspect)
@aspect2 = @user2.aspect(:name => 'failures')
friend_users(@user, @aspect, @user2, @aspect2)
@aspect.reload
aspect
user.activate_friend(friend, aspect)
aspect2
friend_users(user, aspect, user2, aspect2)
aspect.reload
user.reload
end
it 'belong to a user' do
@aspect.user.id.should == @user.id
@user.aspects.size.should == 1
aspect.user.id.should == user.id
user.aspects.should == [aspect]
end
it 'should have people' do
@aspect.people.all.include?(@friend).should be true
@aspect.people.size.should == 2
aspect.people.all.include?(friend).should be true
aspect.people.size.should == 2
end
it 'should be accessible through the user' do
aspects = @user.aspects_with_person(@friend)
aspects = user.aspects_with_person(friend)
aspects.size.should == 1
aspects.first.id.should == @aspect.id
aspects.first.id.should == aspect.id
aspects.first.people.size.should == 2
aspects.first.people.include?(@friend).should be true
aspects.first.people.include?(@user2.person).should be true
aspects.first.people.include?(friend).should be true
aspects.first.people.include?(user2.person).should be true
end
end
describe 'posting' do
it 'should add post to aspect via post method' do
aspect = @user.aspect(:name => 'losers', :people => [@friend])
aspect = user.aspect(:name => 'losers', :people => [friend])
status_message = @user.post( :status_message, :message => "hey", :to => aspect.id )
status_message = user.post( :status_message, :message => "hey", :to => aspect.id )
aspect.reload
aspect.posts.include?(status_message).should be true
end
it 'should add post to aspect via receive method' do
aspect = @user.aspect(:name => 'losers')
aspect2 = @user2.aspect(:name => 'winners')
friend_users(@user, aspect, @user2, aspect2)
aspect = user.aspect(:name => 'losers')
aspect2 = user2.aspect(:name => 'winners')
friend_users(user, aspect, user2, aspect2)
message = @user2.post(:status_message, :message => "Hey Dude", :to => aspect2.id)
message = user2.post(:status_message, :message => "Hey Dude", :to => aspect2.id)
@user.receive message.to_diaspora_xml, @user2.person
user.receive message.to_diaspora_xml, user2.person
aspect.reload
aspect.posts.include?(message).should be true
@user.visible_posts(:by_members_of => aspect).include?(message).should be true
user.visible_posts(:by_members_of => aspect).include?(message).should be true
end
it 'should retract the post from the aspects as well' do
aspect = @user.aspect(:name => 'losers')
aspect2 = @user2.aspect(:name => 'winners')
friend_users(@user, aspect, @user2, aspect2)
aspect = user.aspect(:name => 'losers')
aspect2 = user2.aspect(:name => 'winners')
friend_users(user, aspect, user2, aspect2)
message = @user2.post(:status_message, :message => "Hey Dude", :to => aspect2.id)
message = user2.post(:status_message, :message => "Hey Dude", :to => aspect2.id)
@user.receive message.to_diaspora_xml, @user2.person
user.receive message.to_diaspora_xml, user2.person
aspect.reload
aspect.post_ids.include?(message.id).should be true
retraction = @user2.retract(message)
@user.receive retraction.to_diaspora_xml, @user2.person
retraction = user2.retract(message)
user.receive retraction.to_diaspora_xml, user2.person
aspect.reload
@ -129,59 +135,128 @@ describe Aspect do
end
end
describe "aspect editing" do
context "aspect management" do
before do
@aspect = @user.aspect(:name => 'losers')
@aspect2 = @user2.aspect(:name => 'failures')
friend_users(@user, @aspect, @user2, @aspect2)
@aspect.reload
@aspect3 = @user.aspect(:name => 'cats')
@user.reload
friend_users(user, aspect, user2, aspect2)
aspect.reload
user.reload
end
describe "#add_person_to_aspect" do
it 'adds the user to the aspect' do
aspect1.people.should_not include user2.person
user.add_person_to_aspect(user2.person.id, aspect1.id)
aspect1.reload
aspect1.people.should include user2.person
end
it 'raises if its an aspect that the user does not own'do
proc{user.add_person_to_aspect(user2.person.id, aspect2.id) }.should raise_error /Can not add person to an aspect you do not own/
end
it 'does not allow to have duplicate people in an aspect' do
proc{user.add_person_to_aspect(not_friend.id, aspect1.id) }.should raise_error /Can not add person you are not friends with/
end
it 'does not allow you to add a person if they are already in the aspect' do
proc{user.add_person_to_aspect(user2.person.id, aspect.id) }.should raise_error /Can not add person who is already in the aspect/
end
end
it 'should be able to move a friend from one of users existing aspects to another' do
@user.move_friend(:friend_id => @user2.person.id, :from => @aspect.id, :to => @aspect3.id)
@aspect.reload
@aspect3.reload
describe '#delete_person_from_aspect' do
it 'deletes a user from the aspect' do
user.add_person_to_aspect(user2.person.id, aspect1.id)
user.reload
user.aspects.find_by_id(aspect1.id).people.include?(user2.person).should be true
user.delete_person_from_aspect(user2.person.id, aspect1.id)
user.reload
user.aspects.find_by_id(aspect1.id).people.include?(user2.person).should be false
end
@aspect.person_ids.include?(@user2.person.id).should be false
@aspect3.people.include?(@user2.person).should be true
it 'should check to make sure you have the aspect ' do
proc{user.delete_person_from_aspect(user2.person.id, aspect2.id) }.should raise_error /Can not delete a person from an aspect you do not own/
end
end
it "should not move a person who is not a friend" do
@user.move_friend(:friend_id => @friend.id, :from => @aspect.id, :to => @aspect3.id)
@aspect.reload
@aspect3.reload
@aspect.people.include?(@friend).should be false
@aspect3.people.include?(@friend).should be false
context 'moving and removing posts' do
let(:message) { user2.post(:status_message, :message => "Hey Dude", :to => aspect2.id)}
let(:message2){user3.post(:status_message, :message => "other post", :to => aspect3.id)}
before do
friend_users(user, aspect, user3, aspect3)
user.receive message.to_diaspora_xml, user2.person
user.receive message2.to_diaspora_xml, user3.person
aspect.reload
@post_count = aspect.posts.count
@post_count1 = aspect1.posts.count
user.reload
end
it 'moves the persons posts into the new aspect' do
user.add_person_to_aspect(user2.person.id, aspect1.id, :posts => [message] )
aspect1.reload
aspect1.posts.should == [message]
end
it 'should remove the users posts from that aspect' do
user.delete_person_from_aspect(user2.person.id, aspect.id)
aspect.reload
aspect.posts.count.should == @post_count - 1
end
it 'should not delete other peoples posts' do
user.delete_person_from_aspect(user2.person.id, aspect.id)
aspect.reload
aspect.posts.should == [message2]
end
describe '#move_friend' do
it 'should be able to move a friend from one of users existing aspects to another' do
user.move_friend(:friend_id => user2.person.id, :from => aspect.id, :to => aspect1.id)
aspect.reload
aspect1.reload
aspect.person_ids.include?(user2.person.id).should be false
aspect1.people.include?(user2.person).should be true
end
it "should not move a person who is not a friend" do
proc{ user.move_friend(:friend_id => friend.id, :from => aspect.id, :to => aspect1.id) }.should raise_error /Can not add person you are not friends with/
aspect.reload
aspect1.reload
aspect.people.include?(friend).should be false
aspect1.people.include?(friend).should be false
end
it "should not move a person to a aspect that's not his" do
proc {user.move_friend(:friend_id => user2.person.id, :from => aspect.id, :to => aspect2.id )}.should raise_error /Can not add person to an aspect you do not own/
aspect.reload
aspect2.reload
aspect.people.include?(user2.person).should be true
aspect2.people.include?(user2.person).should be false
end
it 'should move all posts by that user to the new aspect' do
user.move_friend(:friend_id => user2.person.id, :from => aspect.id, :to => aspect1.id)
aspect.reload
aspect1.reload
aspect1.posts.count.should == @post_count1 + 1
aspect.posts.count.should == @post_count - 1
end
it 'does not try to delete if add person did not go through' do
user.should_receive(:add_person_to_aspect).and_return(false)
user.should_not_receive(:delete_person_from_aspect)
user.move_friend(:friend_id => user2.person.id, :from => aspect.id, :to => aspect1.id)
end
end
end
it "should not move a person to a aspect that's not his" do
@user.move_friend(:friend_id => @user2.person.id, :from => @aspect.id, :to => @aspect2.id)
@aspect.reload
@aspect2.reload
@aspect.people.include?(@user2.person).should be true
@aspect2.people.include?(@user2.person).should be false
end
it 'should move all the by that user to the new aspect' do
message = @user2.post(:status_message, :message => "Hey Dude", :to => @aspect2.id)
@user.receive message.to_diaspora_xml, @user2.person
@aspect.reload
@aspect.posts.count.should == 1
@aspect3.posts.count.should == 0
@user.reload
@user.move_friend(:friend_id => @user2.person.id, :from => @aspect.id, :to => @aspect3.id)
@aspect.reload
@aspect3.reload
@aspect3.posts.count.should == 1
@aspect.posts.count.should == 0
end
end
end

20
spec/models/person_spec.rb
View file

@ -187,6 +187,26 @@ describe Person do
end
end
it 'identifier should be a valid email' do
stub_success("joe.valid+email@my-address.com")
Proc.new {
Person.by_webfinger("joe.valid+email@my-address.com")
}.should_not raise_error(RuntimeError, "Identifier is invalid")
stub_success("not_a_@valid_email")
Proc.new {
Person.by_webfinger("not_a_@valid_email")
}.should raise_error(RuntimeError, "Identifier is invalid")
end
it 'should not accept a port number' do
stub_success("eviljoe@diaspora.local:3000")
Proc.new {
Person.by_webfinger('eviljoe@diaspora.local:3000')
}.should raise_error(RuntimeError, "Identifier is invalid")
end
it 'creates a stub for a remote user' do
stub_success("tom@tom.joindiaspora.com")
tom = Person.by_webfinger('tom@tom.joindiaspora.com')

20
spec/models/user/user_friending_spec.rb
View file

@ -160,24 +160,20 @@ describe User do
describe 'unfriending' do
before do
friend_users(user,aspect, user2, aspect2)
user.reload
user2.reload
end
it 'should unfriend the other user on the same seed' do
user.friends.count.should == 1
user2.friends.count.should == 1
user2.unfriend user.person
user2.reload
user2.friends.count.should == 0
user.unfriended_by user2.person
aspect.reload.people.count.should == 0
lambda {user2.unfriend user.person}.should change{
user2.friends.count}.by(-1)
aspect2.reload.people.count.should == 0
end
it 'is unfriended by another user' do
lambda {user.unfriended_by user2.person}.should change{
user.friends.count}.by(-1)
aspect.reload.people.count.should == 0
end
context 'with a post' do
before do
@message = user.post(:status_message, :message => "hi", :to => aspect.id)

15
spec/models/user/visible_posts_spec.rb
View file

@ -23,6 +23,7 @@ describe User do
before do
friend_users(user, first_aspect, user2, user2.aspects.first)
friend_users(user, second_aspect, user3, user3.aspects.first)
end
describe "#visible_posts" do
@ -48,7 +49,6 @@ describe User do
end
it "queries by aspect" do
friend_users(user, second_aspect, user3, user3.aspects.first)
friend_users(user, second_aspect, user4, user4.aspects.first)
user.receive status_message4.to_diaspora_xml, user2.person
@ -67,6 +67,19 @@ describe User do
user.find_visible_post_by_id(status_message1.id).should == nil
end
end
describe '#find_friend_by_id' do
it 'should find both friends' do
user.reload
user.find_friend_by_id(user2.person.id).should == user2.person
user.find_friend_by_id(user3.person.id).should == user3.person
end
it 'should not find a non-friend' do
user3.find_friend_by_id(user4.person.id).should be nil
end
end
end
context 'albums' do

47
spec/models/user_spec.rb
View file

@ -86,17 +86,29 @@ describe User do
end
end
describe ".instantiate!" do
it "creates the user if params are valid" do
User.find_by_username("ohai").should be_nil
user = User.instantiate!({
:username => "ohai",
:email => "ohai@example.com",
:password => "password",
:password_confirmation => "password",
:person => {:profile => {:first_name => "O", :last_name => "Hai"}}})
user.should be_valid
User.find_by_username("ohai").should == user
describe ".build" do
context 'with valid params' do
before do
params = {:username => "ohai",
:email => "ohai@example.com",
:password => "password",
:password_confirmation => "password",
:person =>
{:profile =>
{:first_name => "O",
:last_name => "Hai"}
}
}
@user = User.build(params)
end
it "makes a valid user" do
@user.should be_valid
User.find_by_username("ohai").should be_nil
end
it 'saves successfully' do
@user.save.should be_true
User.find_by_username("ohai").should == @user
end
end
describe "with invalid params" do
before do
@ -107,16 +119,11 @@ describe User do
:password_confirmation => "password",
:person => {:profile => {:first_name => "", :last_name => ""}}}
end
it "raises an error" do
lambda { User.instantiate!(@invalid_params) }.should raise_error
it "raises no error" do
lambda { User.build(@invalid_params) }.should_not raise_error
end
it "does not create the user" do
User.find_by_username("ohai").should be_nil
begin
User.instantiate!(@invalid_params)
rescue
end
User.find_by_username("ohai").should be_nil
it "does not save" do
User.build(@invalid_params).save.should be_false
end
end
end