seth
/
jam-cloud
mirror of https://bitbucket.org/jamkazam/jam-cloud.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

* VRFS-98: join_request added and related changes

This commit is contained in:
Seth Call 2012-11-30 09:23:43 -06:00
parent 773046ea42
commit dc8aca38f6
15 changed files with 443 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/jam_ruby.rb
View File

@ -23,6 +23,7 @@ require "jam_ruby/message_factory"
require "jam_ruby/models/genre"
require "jam_ruby/models/user"
require "jam_ruby/models/user_authorization"
require "jam_ruby/models/join_request"
require "jam_ruby/models/band"
require "jam_ruby/models/connection"
require "jam_ruby/models/friendship"

2
lib/jam_ruby/base_manager.rb
View File

@ -12,7 +12,7 @@ module JamRuby
end
end
# Creates a connection manager, and associates the connection created by active_record with ourselves
# Creates a connection manager, and associates the connection created by active_record with ourselves
def self.active_record_transaction(&block)
manager = self.new

201
lib/jam_ruby/connection_manager.rb
View File

@ -13,7 +13,7 @@ module JamRuby
# Or of course we could just port the relevant methods to node-js
class ConnectionManager < BaseManager
attr_accessor :mq_router
attr_accessor :mq_router
def initialize(options={})
super(options)
@ -28,37 +28,45 @@ module JamRuby
# remove stale connections
def remove_stale_connections(max_seconds)
stale_clients = []
@pg_conn.exec("SELECT client_id FROM connections WHERE updated_at < (NOW() - interval '#{max_seconds} second')") do |result|
result.each do |row|
stale_clients.push(row['client_id'])
ConnectionManager.active_record_transaction do |connection_manager|
conn = connection_manager.pg_conn
stale_clients = []
conn.exec("SELECT client_id FROM connections WHERE updated_at < (NOW() - interval '#{max_seconds} second')") do |result|
result.each do |row|
stale_clients.push(row['client_id'])
end
end
end
@log.debug("deleting #{stale_clients.length} stale connections")
@log.debug("deleting #{stale_clients.length} stale connections")
stale_clients.each do |client_id|
delete_connection(client_id)
stale_clients.each do |client_id|
delete_connection(client_id)
end
end
end
def create_connection(user_id, client_id, ip_address)
conn = @pg_conn
ConnectionManager.active_record_transaction do |connection_manager|
conn = connection_manager.pg_conn
lock_connections(conn)
lock_connections(conn)
conn.exec("INSERT INTO connections (user_id, client_id, ip_address) VALUES ($1, $2, $3)", [user_id, client_id, ip_address]).clear
conn.exec("INSERT INTO connections (user_id, client_id, ip_address) VALUES ($1, $2, $3)", [user_id, client_id, ip_address]).clear
# we just created a new connection-if this is the first time the user has shown up, we need to send out a message to his friends
conn.exec("SELECT count(user_id) FROM connections WHERE user_id = $1", [user_id]) do |result|
count = result.getvalue(0, 0)
if count == "1"
# get all friend user_ids using the same query rails does for @user.friends
friend_update = @message_factory.friend_update(user_id, true)
friend_ids = gather_friends(conn, user_id)
@mq_router.publish_to_friends(friend_ids, friend_update, user_id)
# we just created a new connection-if this is the first time the user has shown up, we need to send out a message to his friends
conn.exec("SELECT count(user_id) FROM connections WHERE user_id = $1", [user_id]) do |result|
count = result.getvalue(0, 0)
if count == "1"
# get all friend user_ids using the same query rails does for @user.friends
friend_update = @message_factory.friend_update(user_id, true)
friend_ids = gather_friends(conn, user_id)
@mq_router.publish_to_friends(friend_ids, friend_update, user_id)
end
end
return Connection.find_by_client_id!(client_id)
end
end
@ -66,47 +74,49 @@ module JamRuby
# once a connection is known gone (whether timeout or because a TCP connection is observed lost)
# this code is responsible for all cleanup logic associated with a connection going away
def delete_connection(client_id)
ConnectionManager.active_record_transaction do |connection_manager|
user_id = nil
music_session_id = nil
conn = connection_manager.pg_conn
conn = @pg_conn
user_id = nil
music_session_id = nil
lock_connections(conn)
lock_connections(conn)
previous_music_session_id = check_already_session(conn, client_id)
previous_music_session_id = check_already_session(conn, client_id)
conn.exec("DELETE FROM connections WHERE client_id = $1 RETURNING user_id, music_session_id", [client_id]) do |result|
conn.exec("DELETE FROM connections WHERE client_id = $1 RETURNING user_id, music_session_id", [client_id]) do |result|
if result.cmd_tuples == 0
# the client is already gone from the database... do nothing but log error
@log.warn("unable to delete client #{client_id}")
return
elsif result.cmd_tuples == 1
user_id = result[0]['user_id']
music_session_id = result[0]['client_id']
if result.cmd_tuples == 0
# the client is already gone from the database... do nothing but log error
@log.warn("unable to delete client #{client_id}")
return
elsif result.cmd_tuples == 1
user_id = result[0]['user_id']
music_session_id = result[0]['client_id']
else
raise Exception, 'uniqueness constraint has been lost on client_id'
else
raise Exception, 'uniqueness constraint has been lost on client_id'
end
end
end
session_checks(conn, previous_music_session_id, user_id)
session_checks(conn, previous_music_session_id, user_id)
# since we did delete a row, check and see if any more connections for that user exist
# if we are down to zero, send out user gone message
conn.exec("SELECT count(user_id) FROM connections where user_id = $1", [user_id]) do |result|
count = result.getvalue(0, 0)
if count == "0"
friend_update = @message_factory.friend_update(user_id, false)
friend_ids = gather_friends(conn, user_id)
@mq_router.publish_to_friends(friend_ids, friend_update, user_id)
# since we did delete a row, check and see if any more connections for that user exist
# if we are down to zero, send out user gone message
conn.exec("SELECT count(user_id) FROM connections where user_id = $1", [user_id]) do |result|
count = result.getvalue(0, 0)
if count == "0"
friend_update = @message_factory.friend_update(user_id, false)
friend_ids = gather_friends(conn, user_id)
@mq_router.publish_to_friends(friend_ids, friend_update, user_id)
end
end
end
# same for session-if we are down to the last participant, delete the session
unless music_session_id.nil?
conn.exec("DELETE FROM music_sessions id = $1 AND 0 = (SELECT count(music_session_id) FROM connections where music_session_id = $1)", [music_session_id]).clear
# same for session-if we are down to the last participant, delete the session
unless music_session_id.nil?
conn.exec("DELETE FROM music_sessions id = $1 AND 0 = (SELECT count(music_session_id) FROM connections where music_session_id = $1)", [music_session_id]).clear
end
end
end
@ -157,7 +167,29 @@ module JamRuby
end
end
def join_music_session(user_id, client_id, music_session_id, as_musician)
def join_music_session(user_id, client_id, music_session_id, as_musician, tracks)
connection = nil
#ConnectionManager.active_record_transaction do |connection_manager|
ActiveRecord::Base.transaction do
connection = Connection.find_by_client_id_and_user_id!(client_id, user_id)
connection.music_session_id = music_session_id
connection.as_musician = as_musician
connection.joining_session = true
associate_tracks(connection, tracks)
connection.save
if connection.errors.any?
raise ActiveRecord::Rollback
else
end
end
return connection
end
def join_music_session_old(user_id, client_id, music_session_id, as_musician)
conn = @pg_conn
lock_connections(conn)
@ -169,13 +201,11 @@ module JamRuby
if as_musician != true && as_musician != false # checks that a boolean was passed in
raise JamArgumentError, "as_musician incorrectly specified"
end
if as_musician && !user.musician
raise PermissionError, "a fan can not join a music session as a musician"
end
# determine if the user can join; if not, throw a PermissionError
music_session = MusicSession.find(music_session_id)
unless music_session.can_join?(user, as_musician)
@log.debug "user can not join a session user_id=#{user_id} and client_id=#{client_id}"
raise PermissionError, "unable to join the specified session"
@ -210,32 +240,35 @@ module JamRuby
end
def leave_music_session(user_id, client_id, music_session_id)
conn = @pg_conn
ConnectionManager.active_record_transaction do |connection_manager|
lock_connections(conn)
conn = connection_manager.pg_conn
previous_music_session_id = check_already_session(conn, client_id)
lock_connections(conn)
if previous_music_session_id == nil
@log.debug "the client is not in a session. user=#{user_id}, client=#{client_id}, music_session=#{music_session_id}"
raise StateError, "not in session"
elsif previous_music_session_id != music_session_id
@log.debug "the client is in a different session. user=#{user_id}, client=#{client_id}, music_session=#{music_session_id}"
raise StateError, "in a session different than that specified"
end
previous_music_session_id = check_already_session(conn, client_id)
# can throw exception if the session is deleted just before this
conn.exec("UPDATE connections SET music_session_id = NULL, as_musician = NULL WHERE client_id = $1 AND user_id =$2", [client_id, user_id]) do |result|
if result.cmd_tuples == 1
@log.debug("deassociated music_session with connection for client_id=#{client_id}, user_id=#{user_id}")
if previous_music_session_id == nil
@log.debug "the client is not in a session. user=#{user_id}, client=#{client_id}, music_session=#{music_session_id}"
raise StateError, "not in session"
elsif previous_music_session_id != music_session_id
@log.debug "the client is in a different session. user=#{user_id}, client=#{client_id}, music_session=#{music_session_id}"
raise StateError, "in a session different than that specified"
end
session_checks(conn, previous_music_session_id, user_id)
elsif result.cmd_tuples == 0
@log.debug "leave_music_session no connection found with client_id=#{client_id}"
raise ActiveRecord::RecordNotFound
else
@log.error("database failure or logic error; this path should be impossible if the table is locked (leave_music_session)")
raise Exception, "locked table changed state"
# can throw exception if the session is deleted just before this
conn.exec("UPDATE connections SET music_session_id = NULL, as_musician = NULL WHERE client_id = $1 AND user_id =$2", [client_id, user_id]) do |result|
if result.cmd_tuples == 1
@log.debug("deassociated music_session with connection for client_id=#{client_id}, user_id=#{user_id}")
session_checks(conn, previous_music_session_id, user_id)
elsif result.cmd_tuples == 0
@log.debug "leave_music_session no connection found with client_id=#{client_id}"
raise ActiveRecord::RecordNotFound
else
@log.error("database failure or logic error; this path should be impossible if the table is locked (leave_music_session)")
raise Exception, "locked table changed state"
end
end
end
end
@ -254,6 +287,22 @@ module JamRuby
return friend_ids
end
def associate_tracks(connection, tracks)
@log.debug "Tracks:"
@log.debug tracks
unless tracks.nil?
tracks.each do |track|
instrument = Instrument.find(track["instrument_id"])
connection_track = ConnectionTrack.new
connection_track.instrument = instrument
connection_track.connection = connection
connection_track.sound = track["sound"]
connection_track.save
connection.connection_tracks << connection_track
end
end
end
end
end

6
lib/jam_ruby/message_factory.rb
View File

@ -96,6 +96,12 @@
return Jampb::ClientMessage.new(:type => ClientMessage::Type::USER_LEFT_MUSIC_SESSION, :route_to => CLIENT_TARGET, :user_left_music_session => left)
end
# create a user-joined session message
def join_request(session_id, join_request_id, username, text)
join_request = Jampb::JoinRequest.new(:join_request_id => join_request_id, :username => username, :text => text)
return Jampb::ClientMessage.new(:type => ClientMessage::Type::JOIN_REQUEST, :route_to => SESSION_TARGET_PREFIX + session_id, :join_request => join_request)
end
# create a test message to send in session
def test_session_message(session_id, msg)
test = Jampb::TestSessionMessage.new(:msg => msg)

3
lib/jam_ruby/models/band.rb
View File

@ -23,6 +23,9 @@ module JamRuby
after_save :limit_to_three_genres
# music_sessions
has_many :music_sessions, :class_name => "JamRuby::MusicSession", :foreign_key => "band_id"
def photo_url
# TODO: move image path to config
@photo_url = "http://www.jamkazam.com/images/bands/photos/#{self.id}.gif"

55
lib/jam_ruby/models/connection.rb
View File

@ -2,6 +2,12 @@ module JamRuby
class Connection < ActiveRecord::Base
SELECT_AT_LEAST_ONE = "Please select at least one track"
FAN_CAN_NOT_JOIN_AS_MUSICIAN = "A fan can not join a music session as a musician"
MUSIC_SESSION_MUST_BE_SPECIFIED = "A music session must be specified"
INVITE_REQUIRED = "You must be invited to join this session"
FANS_CAN_NOT_JOIN = "Fans can not join this session"
attr_accessor :joining_session
self.primary_key = 'id'
@ -9,14 +15,59 @@ module JamRuby
belongs_to :music_session, :class_name => "JamRuby::MusicSession"
has_many :connection_tracks, :class_name => "JamRuby::ConnectionTrack", :inverse_of => :connection
after_save :require_at_least_one_track_when_in_session
validates :as_musician, :inclusion => {:in => [true, false]}
validate :can_join_music_session, :if => :joining_session?
after_save :require_at_least_one_track_when_in_session, :if => :joining_session?
def joining_session?
return joining_session
end
def can_join_music_session
if music_session.nil?
errors.add(:music_session, MUSIC_SESSION_MUST_BE_SPECIFIED)
return false
end
if as_musician
unless self.user.musician
errors.add(:as_musician, FAN_CAN_NOT_JOIN_AS_MUSICIAN)
return false
end
if music_session.musician_access
if music_session.approval_required
unless music_session.creator == user || music_session.invited_musicians.exists?(user)
errors.add(:approval_required, INVITE_REQUIRED)
return false
end
end
else
unless music_session.creator == user || music_session.invited_musicians.exists?(user)
errors.add(:musician_access, INVITE_REQUIRED)
return false
end
end
else
unless self.music_session.fan_access
# it's someone joining as a fan, and the only way a fan can join is if fan_access is true
errors.add(:fan_access, FANS_CAN_NOT_JOIN)
return false
end
end
return true
end
# decides if a given user can access this client with p2p messaging
# the answer is yes if the user is in the same music session
def access_p2p?(user)
return self.music_session.users.exists?(user)
end
private
def require_at_least_one_track_when_in_session
if connection_tracks.count == 0

17
lib/jam_ruby/models/invitation.rb
View File

@ -3,17 +3,19 @@ module JamRuby
FRIENDSHIP_REQUIRED_VALIDATION_ERROR = "You can only invite friends"
MEMBERSHIP_REQUIRED_OF_MUSIC_SESSION = "You must be a member of the music session to send invitations on behalf of it"
JOIN_REQUEST_IS_NOT_FOR_RECEIVER_AND_MUSIC_SESSION = "You can only associate a join request with an invitation if that join request comes from the invited user and if it's for the same music session"
self.primary_key = 'id'
belongs_to :sender, :inverse_of => :sent_invitations, :class_name => "JamRuby::User", :foreign_key => "sender_id"
belongs_to :receiver, :inverse_of => :received_invitations, :class_name => "JamRuby::User", :foreign_key => "receiver_id"
belongs_to :music_session, :inverse_of => :invitations, :class_name => "JamRuby::MusicSession"
belongs_to :join_request, :inverse_of => :invitations, :class_name => "JamRuby::JoinRequest"
validates :sender, :presence => true
validates :receiver, :presence => true
validates :music_session, :presence => true
validate :require_sender_in_music_session, :require_are_friends
validate :require_sender_in_music_session, :require_are_friends_or_requested_to_join
private
@ -23,9 +25,14 @@ module JamRuby
end
end
def require_are_friends
unless receiver.friends.exists? sender
errors.add(:receiver, FRIENDSHIP_REQUIRED_VALIDATION_ERROR)
def require_are_friends_or_requested_to_join
if !join_request.nil? && (join_request.user != receiver || join_request.music_session != music_session)
errors.add(:join_request, JOIN_REQUEST_IS_NOT_FOR_RECEIVER_AND_MUSIC_SESSION )
elsif join_request.nil?
# we only check for friendship requirement if this was not in response to a join_request
unless receiver.friends.exists? sender
errors.add(:receiver, FRIENDSHIP_REQUIRED_VALIDATION_ERROR)
end
end
end
end

44
lib/jam_ruby/models/join_request.rb Normal file
View File

@ -0,0 +1,44 @@
module JamRuby
class JoinRequest < ActiveRecord::Base
REQUESTOR_MUST_BE_A_MUSICIAN = "requestor must be a musician"
self.primary_key = 'id'
belongs_to :user, :class_name => "JamRuby::User"
belongs_to :music_session, :class_name => "JamRuby::MusicSession"
has_many :invitations, :inverse_of => :join_request, :class_name => "JamRuby::Invitation"
validates :user, :presence => true
validates :music_session, :presence => true
validates :text, presence: false, length: {maximum: 140} # arbitrary decision of 140. the database is at 2000 max on this field
validates_uniqueness_of :user_id, :scope => :music_session_id
validate :requestor_is_musician
# list all paginations for the current user
def self.index(current_user)
# TODO pagination
return JoinRequest.where("join_requests.user_id = '#{current_user.id}'").order('join_requests.created_at DESC')
end
def requestor_is_musician
unless user.musician?
errors.add(:user, REQUESTOR_MUST_BE_A_MUSICIAN)
end
end
def to_s
return "#{self.user.to_s}:#{self.music_session.to_s}"
end
# permissions:
# only the creator of the join request can do a get
# or a member of the music_session that the join_request is designated for
def self.show(id, user)
return JoinRequest.find(id, :conditions => ["user_id = ? OR music_session_id IN (select music_session_id from connections WHERE user_id = ?)", user.id, user.id])
end
end
end

29
lib/jam_ruby/models/music_session.rb
View File

@ -10,30 +10,49 @@ module JamRuby
has_many :connections, :class_name => "JamRuby::Connection"
has_many :users, :through => :connections, :class_name => "JamRuby::User"
has_and_belongs_to_many :genres, :class_name => "::JamRuby::Genre", :join_table => "genres_music_sessions"
has_many :join_requests, :foreign_key => "music_session_id", :inverse_of => :music_session, :class_name => "JamRuby::JoinRequest"
has_many :invitations, :foreign_key => "music_session_id", :inverse_of => :music_session, :class_name => "JamRuby::Invitation"
has_many :invited_musicians, :through => :invitations, :class_name => "JamRuby::User", :foreign_key => "receiver_id", :source => :receiver
has_many :fan_invitations, :foreign_key => "music_session_id", :inverse_of => :music_session, :class_name => "JamRuby::FanInvitation"
has_many :invited_fans, :through => :fan_invitations, :class_name => "JamRuby::User", :foreign_key => "receiver_id", :source => :receiver
belongs_to :band, :inverse_of => :music_sessions, :class_name => "JamRuby::Band", :foreign_key => "band_id"
after_save :require_at_least_one_genre, :limit_to_three_genres
validates :fan_chat, :inclusion => {:in => [true, false]}
validates :fan_access, :inclusion => {:in => [true, false]}
validates :approval_required, :inclusion => {:in => [true, false]}
validates :musician_access, :inclusion => {:in => [true, false]}
validates :creator, :presence => true, :if => "creator.musician?"
validates :creator, :presence => true
validate :creator_is_musician
def creator_is_musician
unless creator.musician?
errors.add(:creator, "creator must be a musician")
end
end
def self.index(current_user)
return MusicSession.includes(:invitations, :connections => [:user => [:friendships]]).order("(invitations.id is NULL) ASC, (friendships.friend_id != '#{current_user.id}' OR friendships.friend_id is NULL) ASC, music_sessions.created_at DESC").where("invitations.receiver_id = '#{current_user.id}' OR (friendships.friend_id = '#{current_user.id}') OR musician_access = true")
end
return MusicSession.includes(:invitations, :join_requests, :connections => [:user => [:friendships]]).order("(invitations.id is NULL) ASC, (friendships.friend_id != '#{current_user.id}' OR friendships.friend_id is NULL) ASC, music_sessions.created_at DESC").where("invitations.receiver_id = '#{current_user.id}' OR (friendships.friend_id = '#{current_user.id}') OR musician_access = true")
end
# Verifies that the specified user can join this music session
def can_join? user, as_musician
if as_musician
if !user.musician
return false # "a fan can not join a music session as a musician"
raise PermissionError, "a fan can not join a music session as a musician"
end
if self.musician_access
return true
if self.approval_required
return self.invited_musicians.exists?(user)
else
return true
end
else
# the creator can always join, and the invited users can join
return self.creator == user || self.invited_musicians.exists?(user)

6
spec/factories.rb
View File

@ -4,6 +4,7 @@ FactoryGirl.define do
password "foobar"
password_confirmation "foobar"
email_confirmed true
musician true
factory :admin do
@ -21,6 +22,7 @@ FactoryGirl.define do
factory :connection, :class => JamRuby::Connection do
sequence(:client_id) { |n| "Client#{n}" }
as_musician true
end
factory :invitation, :class => JamRuby::Invitation do
@ -34,4 +36,8 @@ FactoryGirl.define do
factory :band, :class => JamRuby::Band do
end
factory :join_request, :class => JamRuby::JoinRequest do
text 'let me in to the session!'
end
end

199
spec/jam_ruby/connection_manager_spec.rb
View File

@ -3,6 +3,7 @@ require 'spec_helper'
# these tests avoid the use of ActiveRecord and FactoryGirl to do blackbox, non test-instrumented tests
describe ConnectionManager do
TRACKS = [{"instrument_id" => "electric guitar", "sound" => "mono"}]
before do
@conn = PG::Connection.new(:dbname => SpecDb::TEST_DB_NAME, :user => "postgres", :password => "postgres", :host => "localhost")
@ -43,11 +44,7 @@ describe ConnectionManager do
end
it "can't create bogus user_id" do
@conn.transaction do
expect { @connman.create_connection("aeonuthaoentuh", "client_id", "1.1.1.1") }.to raise_error(PG::Error)
end
end
it "can't create two client_ids of same value" do
@ -55,27 +52,23 @@ describe ConnectionManager do
client_id = "client_id1"
user_id = create_user("test", "user1", "user1@jamkazam.com")
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
expect { @connman.create_connection(user_id, client_id, "1.1.1.1") }.to raise_error(PG::Error)
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
expect { @connman.create_connection(user_id, client_id, "1.1.1.1") }.to raise_error(PG::Error)
end
it "create connection then delete it" do
client_id = "client_id2"
user_id = create_user("test", "user2", "user2@jamkazam.com")
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
end
connection = @connman.create_connection(user_id, client_id, "1.1.1.1")
# make sure the connection is seen
@conn.exec("SELECT count(*) FROM connections where user_id = $1", [user_id]) do |result|
result.getvalue(0, 0).should == "1"
end
@conn.transaction do
@connman.delete_connection(client_id)
end
@connman.delete_connection(client_id)
@conn.exec("SELECT count(*) FROM connections where user_id = $1", [user_id]) do |result|
result.getvalue(0, 0).should == "0"
@ -93,16 +86,12 @@ describe ConnectionManager do
friend_update = @message_factory.friend_update(user_id, true)
@connman.mq_router.should_receive(:publish_to_friends).with([], friend_update, user_id)
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
# but a second connection from the same user should cause no such message
@connman.should_receive(:publish_to_friends).exactly(0).times
@conn.transaction do
@connman.create_connection(user_id, client_id2, "1.1.1.1")
end
@connman.create_connection(user_id, client_id2, "1.1.1.1")
end
@ -116,30 +105,19 @@ describe ConnectionManager do
# we should get a message saying that this user is online
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
end
@conn.transaction do
@connman.create_connection(user_id, client_id2, "1.1.1.1")
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
@connman.create_connection(user_id, client_id2, "1.1.1.1")
# deleting one of the two connections should cause no messages
@connman.should_receive(:publish_to_friends).exactly(0).times
@conn.transaction do
@connman.delete_connection(client_id)
end
@connman.delete_connection(client_id)
# but deleting the final connection should cause a left message
friend_update = @message_factory.friend_update(user_id, false)
@connman.mq_router.should_receive(:publish_to_friends).with([], friend_update, user_id)
@conn.transaction do
@connman.delete_connection(client_id2)
end
@connman.delete_connection(client_id2)
end
it "lookup of friends should find mutual friends only" do
@ -197,22 +175,16 @@ describe ConnectionManager do
user_id = create_user("test", "user8", "user8@jamkazam.com")
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
@conn.transaction do
@connman.remove_stale_connections(60)
end
@connman.remove_stale_connections(60)
assert_num_connections(client_id, 1)
sleep(1)
@conn.transaction do
# this should remove the stale connection
@connman.remove_stale_connections(1)
end
# this should remove the stale connection
@connman.remove_stale_connections(1)
assert_num_connections(client_id, 0)
end
@ -223,20 +195,18 @@ describe ConnectionManager do
user_id = create_user("test", "user9", "user9@jamkazam.com")
music_session_id = create_music_session(user_id)
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
@connman.join_music_session(user_id, client_id, music_session_id, true)
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
connection = @connman.join_music_session(user_id, client_id, music_session_id, true, TRACKS)
connection.errors.any?.should be_false
assert_session_exists(music_session_id, true)
@conn.exec("SELECT music_session_id FROM connections WHERE client_id = $1", [client_id]) do |result|
result.getvalue(0, 0).should == music_session_id
end
@conn.transaction do
@connman.delete_connection(client_id)
end
@connman.delete_connection(client_id)
assert_num_connections(client_id, 0)
assert_session_exists(music_session_id, false)
@ -248,49 +218,53 @@ describe ConnectionManager do
user_id = create_user("test", "user10", "user10@jamkazam.com")
music_session_id = create_music_session(user_id)
@conn.transaction do
expect { @connman.join_music_session(user_id, client_id, music_session_id, true) }.to raise_error(ActiveRecord::RecordNotFound)
end
expect { @connman.join_music_session(user_id, client_id, music_session_id, true, TRACKS) }.to raise_error(ActiveRecord::RecordNotFound)
end
it "join_music_session fails if user is a fan but wants to join as a musician" do
client_id = "client_id10.1"
user_id = create_user("test", "user10.1", "user10.1@jamkazam.com", :musician => false)
client_id = "client_id10.11"
client_id2 = "client_id10.12"
user_id = create_user("test", "user10.11", "user10.11@jamkazam.com", :musician => true)
user_id2 = create_user("test", "user10.12", "user10.12@jamkazam.com", :musician => false)
@connman.create_connection(user_id, client_id, "1.1.1.1")
@connman.create_connection(user_id2, client_id2, "1.1.1.1")
music_session_id = create_music_session(user_id)
@connman.join_music_session(user_id, client_id, music_session_id, true, TRACKS)
@conn.transaction do
expect { @connman.join_music_session(user_id, client_id, music_session_id, true) }.to raise_error(JamRuby::PermissionError)
end
connection = @connman.join_music_session(user_id2, client_id2, music_session_id, true, TRACKS)
connection.errors.size.should == 1
connection.errors.get(:as_musician).should == [Connection::FAN_CAN_NOT_JOIN_AS_MUSICIAN]
end
it "join_music_session fails if invalid value for as_musician specified" do
it "as_musician is coerced to boolean" do
client_id = "client_id10.2"
user_id = create_user("test", "user10.2", "user10.2@jamkazam.com", :musician => false)
@connman.create_connection(user_id, client_id, "1.1.1.1")
music_session_id = create_music_session(user_id)
@conn.transaction do
expect { @connman.join_music_session(user_id, client_id, music_session_id, 'blarg') }.to raise_error(JamRuby::JamArgumentError)
end
connection = @connman.join_music_session(user_id, client_id, music_session_id, 'blarg', TRACKS)
connection.errors.size.should == 0
connection.as_musician.should be_false
end
it "join_music_session fails if fan_access=false and the user is a fan" do
client_id = "client_id10.3"
user_id = create_user("test", "user10.3", "user10.3@jamkazam.com", :musician => false)
music_session_id = create_music_session(user_id, :fan_access => false)
@conn.transaction do
expect { @connman.join_music_session(user_id, client_id, music_session_id, false) }.to raise_error(JamRuby::PermissionError)
end
musician_client_id = "client_id10.3"
fan_client_id = "client_id10.4"
musician = create_user("test", "user10.3", "user10.3@jamkazam.com")
fan = create_user("test", "user10.4", "user10.4@jamkazam.com", :musician => false)
@connman.create_connection(musician, musician_client_id, "1.1.1.1")
@connman.create_connection(fan, fan_client_id, "1.1.1.1")
music_session_id = create_music_session(musician, :fan_access => false)
@connman.join_music_session(musician, musician_client_id, music_session_id, true, TRACKS)
# now join the session as a fan, bt fan_access = false
connection = @connman.join_music_session(fan, fan_client_id, music_session_id, false, TRACKS)
connection.errors.size.should == 1
end
it "join_music_session fails if incorrect user_id specified" do
@ -300,40 +274,41 @@ describe ConnectionManager do
user_id2 = create_user("test", "user21", "user21@jamkazam.com")
music_session_id = create_music_session(user_id)
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
# specify real user id, but not associated with this session
expect { @connman.join_music_session(user_id2, client_id, music_session_id, true) } .to raise_error(ActiveRecord::RecordNotFound)
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
# specify real user id, but not associated with this session
expect { @connman.join_music_session(user_id2, client_id, music_session_id, true, TRACKS) } .to raise_error(ActiveRecord::RecordNotFound)
end
it "join_music_session fails if no music_session" do
client_id = "client_id11"
user_id = create_user("test", "user11", "user11@jamkazam.com")
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
end
@conn.transaction do
expect { @connman.join_music_session(user_id, client_id, "some_bogus_music_session_id", true) }.to raise_error(ActiveRecord::RecordNotFound)
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
connection = @connman.join_music_session(user_id, client_id, "some_bogus_music_session_id", true, TRACKS)
connection.errors.size.should == 1
connection.errors.get(:music_session).should == [Connection::MUSIC_SESSION_MUST_BE_SPECIFIED]
end
it "join_music_session fails if approval_required and no invitation, but generates join_request" do
client_id = "client_id11.1"
user_id = create_user("test", "user11.1", "user11.1@jamkazam.com")
user_id2 = create_user("test", "user11.2", "user11.2@jamkazam.com")
music_session_id = create_music_session(user_id, :approval_required => true)
@connman.create_connection(user_id, client_id, "1.1.1.1")
# specify real user id, but not associated with this session
expect { @connman.join_music_session(user_id2, client_id, music_session_id, true, TRACKS) } .to raise_error(ActiveRecord::RecordNotFound)
end
it "leave_music_session fails if no music_session" do
client_id = "client_id12"
user_id = create_user("test", "user12", "user12@jamkazam.com")
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
@conn.transaction do
expect { @connman.leave_music_session(user_id, client_id, "some_bogus_music_session_id") }.to raise_error(JamRuby::StateError)
end
expect { @connman.leave_music_session(user_id, client_id, "some_bogus_music_session_id") }.to raise_error(JamRuby::StateError)
end
it "leave_music_session fails if in different music_session" do
@ -342,17 +317,9 @@ describe ConnectionManager do
user_id = create_user("test", "user13", "user13@jamkazam.com")
music_session_id = create_music_session(user_id)
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
end
@conn.transaction do
@connman.join_music_session(user_id, client_id, music_session_id, true)
end
@conn.transaction do
expect { @connman.leave_music_session(user_id, client_id, "some_bogus_music_session_id") }.to raise_error(JamRuby::StateError)
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
@connman.join_music_session(user_id, client_id, music_session_id, true, TRACKS)
expect { @connman.leave_music_session(user_id, client_id, "some_bogus_music_session_id") }.to raise_error(JamRuby::StateError)
end
it "leave_music_session works" do
@ -361,14 +328,8 @@ describe ConnectionManager do
user_id = create_user("test", "user14", "user14@jamkazam.com")
music_session_id = create_music_session(user_id)
@conn.transaction do
@connman.create_connection(user_id, client_id, "1.1.1.1")
end
@conn.transaction do
@connman.join_music_session(user_id, client_id, music_session_id, true)
end
@connman.create_connection(user_id, client_id, "1.1.1.1")
@connman.join_music_session(user_id, client_id, music_session_id, true, TRACKS)
assert_session_exists(music_session_id, true)
@ -376,9 +337,7 @@ describe ConnectionManager do
result.getvalue(0, 0).should == music_session_id
end
@conn.transaction do
@connman.leave_music_session(user_id, client_id, music_session_id)
end
@connman.leave_music_session(user_id, client_id, music_session_id)
@conn.exec("SELECT music_session_id FROM connections WHERE client_id = $1", [client_id]) do |result|
result.getvalue(0, 0).should == nil
@ -386,9 +345,7 @@ describe ConnectionManager do
assert_session_exists(music_session_id, false)
@conn.transaction do
@connman.delete_connection(client_id)
end
@connman.delete_connection(client_id)
assert_num_connections(client_id, 0)

38
spec/jam_ruby/models/invitation_spec.rb
View File

@ -14,7 +14,7 @@ describe MusicSession do
invitation = Invitation.new(:sender => user1, :receiver => user2, :music_session => music_session)
invitation.save.should == false
invitation.save.should be_false
invitation.errors.size.should == 1
invitation.errors.get(:receiver).should == [Invitation::FRIENDSHIP_REQUIRED_VALIDATION_ERROR]
end
@ -34,6 +34,40 @@ describe MusicSession do
invitation = Invitation.new(:sender => user1, :receiver => user2, :music_session => music_session)
invitation.save.should == true
invitation.save.should be_true
end
it 'can create invitation to a user who made a join_request' do
user1 = FactoryGirl.create(:user) # in the jam session
user2 = FactoryGirl.create(:user) # in the jam session
music_session = FactoryGirl.create(:music_session, :creator => user1)
music_session_member1 = FactoryGirl.create(:connection, :user => user1, :music_session => music_session, :ip_address => "1.1.1.1", :client_id => "1")
connection2 = FactoryGirl.create(:connection, :user => user2, :ip_address => "2.2.2.2", :client_id => "2")
join_request = FactoryGirl.create(:join_request, :user => user2, :music_session => music_session)
invitation = Invitation.new(:sender => user1, :receiver => user2, :music_session => music_session, :join_request => join_request)
invitation.save.should be_true
end
it 'cant create invitation to a user who did not make a join_request and is not a friend' do
user1 = FactoryGirl.create(:user) # in the jam session
user2 = FactoryGirl.create(:user) # in the jam session
music_session = FactoryGirl.create(:music_session, :creator => user1)
music_session2 = FactoryGirl.create(:music_session, :creator => user1)
music_session_member1 = FactoryGirl.create(:connection, :user => user1, :music_session => music_session, :ip_address => "1.1.1.1", :client_id => "1")
connection2 = FactoryGirl.create(:connection, :user => user2, :ip_address => "2.2.2.2", :client_id => "2")
join_request = FactoryGirl.create(:join_request, :user => user2, :music_session => music_session2)
invitation = Invitation.new(:sender => user1, :receiver => user2, :music_session => music_session, :join_request => join_request)
invitation.save.should be_false
invitation.errors.get(:join_request).should == [Invitation::JOIN_REQUEST_IS_NOT_FOR_RECEIVER_AND_MUSIC_SESSION ]
end
end

42
spec/jam_ruby/models/join_request_spec.rb Normal file
View File

@ -0,0 +1,42 @@
require 'spec_helper'
describe JoinRequest do
it 'can create a join request' do
user1 = FactoryGirl.create(:user)
music_session = FactoryGirl.create(:music_session, :creator => user1)
music_session_member1 = FactoryGirl.create(:connection, :user => user1, :music_session => music_session)
join_request = JoinRequest.new(:user => user1, :music_session => music_session, :text => "Let me join yo")
join_request.save.should be_true
join_requests = JoinRequest.index(user1)
join_requests.length.should == 1
join_requests[0].id.should == join_request.id
end
it 'fans cant create a join request' do
user1 = FactoryGirl.create(:user, :musician => true)
user2 = FactoryGirl.create(:user, :musician => false)
music_session = FactoryGirl.create(:music_session, :creator => user1)
music_session_member1 = FactoryGirl.create(:connection, :user => user1, :music_session => music_session)
join_request = JoinRequest.new(:user => user2, :music_session => music_session, :text => "Let me join yo")
join_request.save.should be_false
join_request.errors.size.should == 1
join_request.errors.get(:user).should == [JoinRequest::REQUESTOR_MUST_BE_A_MUSICIAN]
end
it 'cant create a dup join_request' do
user1 = FactoryGirl.create(:user)
music_session = FactoryGirl.create(:music_session, :creator => user1)
music_session_member1 = FactoryGirl.create(:connection, :user => user1, :music_session => music_session)
join_request = JoinRequest.new(:user => user1, :music_session => music_session, :text => "Let me join yo")
join_request.save.should be_true
join_request2 = JoinRequest.new(:user => user1, :music_session => music_session, :text => "Let me join yo")
join_request2.save.should be_false
join_request2.errors.get(:user_id) == ["has already been taken"]
end
end

11
spec/jam_ruby/models/music_session_spec.rb
View File

@ -178,4 +178,15 @@ describe MusicSession do
music_sessions[3].id.should == music_session2.id
end
it 'uninvited users cant join approval-required sessions without invitation' do
user1 = FactoryGirl.create(:user) # in the jam session
user2 = FactoryGirl.create(:user) # in the jam session
music_session = FactoryGirl.create(:music_session, :creator => user1, :musician_access => true, :approval_required => true)
connection1 = FactoryGirl.create(:connection, :user => user1, :music_session => music_session)
expect { FactoryGirl.create(:connection, :user => user2, :music_session => music_session, :joining_session => true) }.to raise_error(ActiveRecord::RecordInvalid)
end
end

2
spec/spec_helper.rb
View File

@ -46,7 +46,7 @@ Spork.prefork do
config.filter_run :focus
config.before(:suite) do
DatabaseCleaner.strategy = :transaction
DatabaseCleaner.strategy = :truncation, {:except => %w[instruments genres] }
DatabaseCleaner.clean_with(:truncation, {:except => %w[instruments genres] })
end