841 lines
39 KiB
Ruby
Executable File
841 lines
39 KiB
Ruby
Executable File
require 'spec_helper'
|
|
|
|
describe "Active Music Session API ", :type => :api do
|
|
|
|
subject { page }
|
|
|
|
before(:each) do
|
|
ActiveMusicSession.delete_all
|
|
end
|
|
|
|
def login(user)
|
|
post '/sessions', "session[email]" => user.email, "session[password]" => user.password
|
|
rack_mock_session.cookie_jar["remember_token"].should == user.remember_token
|
|
end
|
|
|
|
def make_friends(user1, user2)
|
|
Friendship.save(user1, user2)
|
|
end
|
|
|
|
describe "profile page" do
|
|
let(:user) { FactoryGirl.create(:user) }
|
|
|
|
# defopts are used to setup default options for the session
|
|
let(:defopts) { { :name => "session name", :description => "session description",
|
|
:genres => ["classical"], :musician_access => true, :approval_required => false,
|
|
:fan_chat => true, :fan_access => true,
|
|
:legal_policy => true, :language => 'eng',
|
|
:timezone => "UTC,Etc/UTC",
|
|
:duration => "60",
|
|
:rsvp_slots => [{proficiency_level: 1, instrument_id: 'other', approve:true}]
|
|
} }
|
|
|
|
let(:defpart) { { :as_musician => true,
|
|
:tracks => [{"instrument_id" => "electric guitar",
|
|
"sound" => "mono",
|
|
"client_track_id" => "client_track_guid"}] } }
|
|
before do
|
|
#sign_in user
|
|
ActiveMusicSession.delete_all
|
|
|
|
login(user)
|
|
end
|
|
|
|
it "should list no sessions" do
|
|
get '/api/sessions.json'
|
|
last_response.body.should eql('[]')
|
|
end
|
|
|
|
it "should create session" do
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1", :client_id => "1")
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
# now fetch it's data
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id, }).to_json, "CONTENT_TYPE" => 'application/json'
|
|
|
|
last_response.status.should eq(201)
|
|
|
|
get '/api/sessions.json'
|
|
music_sessions = JSON.parse(last_response.body)
|
|
music_session = music_sessions[0]
|
|
music_session["id"].should == music_sessions[0]["id"]
|
|
music_session["musician_access"].should be true
|
|
music_session["invitations"].should == []
|
|
music_session["join_requests"].should == []
|
|
music_session["approval_required"].should be false
|
|
music_session["fan_chat"].should be true
|
|
music_session["fan_access"].should be true
|
|
music_session["participants"].length.should == 1
|
|
participant = music_session["participants"][0]
|
|
participant["ip_address"].should == client.ip_address
|
|
participant["client_id"].should == client.client_id
|
|
participant["tracks"].length.should == 1
|
|
track = participant["tracks"][0]
|
|
track["instrument_id"].should == "electric guitar"
|
|
track["sound"].should == "mono"
|
|
|
|
# test session settings - UNUSED FOR A VERY LONG TIME. TEST STARTED TO FAIL, COMMENTED IT OUT
|
|
#get '/api/users/' + user.id + '/session_settings.json'
|
|
#session_settings = JSON.parse(last_response.body)
|
|
##session_settings["musician_access"].should be true
|
|
#session_settings["approval_required"].should be false
|
|
#session_settings["fan_chat"].should be true
|
|
#session_settings["fan_access"].should be true
|
|
|
|
# test session history
|
|
get '/api/users/' + user.id + '/session_history.json'
|
|
last_response.status.should == 200
|
|
session_history = JSON.parse(last_response.body)
|
|
session_history[0]["user_id"].to_s.should == user.id
|
|
session_history[0]["band_id"].should == music_session["band_id"]
|
|
session_history[0]["description"].should == music_session["description"]
|
|
|
|
get '/api/users/' + user.id + '/session_history/' + music_session["id"] + '/users.json'
|
|
|
|
# test Track-specific APIs
|
|
get "/api/sessions/#{music_session["id"]}/tracks.json", "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 200
|
|
tracks = JSON.parse(last_response.body)
|
|
tracks.size.should == 1
|
|
tracks[0]["instrument_id"].should == "electric guitar"
|
|
tracks[0]["sound"].should == "mono"
|
|
|
|
# change instrument
|
|
post "/api/sessions/#{music_session["id"]}/tracks/#{tracks[0]["id"]}.json", { :instrument_id => "drums" }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 200
|
|
|
|
# get individual track
|
|
get "/api/sessions/#{music_session["id"]}/tracks/#{tracks[0]["id"]}.json", "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 200
|
|
updated_track = JSON.parse(last_response.body)
|
|
updated_track["instrument_id"].should == "drums"
|
|
updated_track["sound"].should == "mono"
|
|
|
|
# change sound
|
|
post "/api/sessions/#{music_session["id"]}/tracks/#{tracks[0]["id"]}.json", { :sound => "stereo" }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 200
|
|
|
|
# get individual track
|
|
get "/api/sessions/#{music_session["id"]}/tracks/#{tracks[0]["id"]}.json", "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 200
|
|
updated_track = JSON.parse(last_response.body)
|
|
updated_track["instrument_id"].should == "drums"
|
|
updated_track["sound"].should == "stereo"
|
|
|
|
# create a 2nd track for this session
|
|
conn_id = updated_track["connection_id"]
|
|
post "/api/sessions/#{music_session["id"]}/tracks.json", { :connection_id => "#{conn_id}", :instrument_id => "electric guitar", :sound => "mono", :client_track_id => "client_track_guid" }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 201
|
|
|
|
get "/api/sessions/#{music_session["id"]}/tracks.json", "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 200
|
|
tracks = JSON.parse(last_response.body)
|
|
tracks.size.should == 2
|
|
|
|
# invalid track ID
|
|
get "/api/sessions/#{music_session["id"]}/tracks/1234.json", "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 404
|
|
|
|
# delete track
|
|
delete "/api/sessions/#{music_session["id"]}/tracks/#{tracks[0]["id"]}.json"
|
|
last_response.status.should == 204
|
|
|
|
# get tracks again
|
|
get "/api/sessions/#{music_session["id"]}/tracks.json", "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 200
|
|
tracks = JSON.parse(last_response.body)
|
|
tracks.size.should == 1
|
|
end
|
|
|
|
|
|
describe "update music session properties" do
|
|
|
|
let(:user) { FactoryGirl.create(:user) }
|
|
let(:music_session) { music_session = FactoryGirl.create(:active_music_session, :creator => user, :description => "My Session") }
|
|
let(:client) { FactoryGirl.create(:connection, :user => user) }
|
|
|
|
it "successful" do
|
|
put "/api/sessions/#{music_session.id}.json", {:description => "you!", :musician_access => false, :fan_chat => false, :fan_access => false, :approval_required => true}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(200)
|
|
get "/api/sessions/#{music_session.id}.json", "CONTENT_TYPE" => 'application/json'
|
|
updated_session = JSON.parse(last_response.body)
|
|
updated_session["description"].should == "you!"
|
|
updated_session["musician_access"].should be false
|
|
updated_session["fan_chat"].should be false
|
|
updated_session["fan_access"].should be false
|
|
updated_session["approval_required"].should be true
|
|
end
|
|
|
|
it "string boolean value" do
|
|
put "/api/sessions/#{music_session.id}.json", {:musician_access => "false"}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(200)
|
|
get "/api/sessions/#{music_session.id}.json", "CONTENT_TYPE" => 'application/json'
|
|
updated_session = JSON.parse(last_response.body)
|
|
updated_session["musician_access"].should be false
|
|
end
|
|
|
|
|
|
it "empty description not allowed" do
|
|
put "/api/sessions/#{music_session.id}.json", {:description => ""}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(422)
|
|
end
|
|
|
|
it "updated genres" do
|
|
put "/api/sessions/#{music_session.id}.json", {:genre => "jazz"}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(200)
|
|
get "/api/sessions/#{music_session.id}.json", "CONTENT_TYPE" => 'application/json'
|
|
updated_session = JSON.parse(last_response.body)
|
|
updated_session["genres"].should == ["Jazz"]
|
|
end
|
|
end
|
|
|
|
|
|
it "should add/remove member from session" do
|
|
# create the session
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
# now fetch it's data
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id, }).to_json, "CONTENT_TYPE" => 'application/json'
|
|
|
|
get "/api/sessions.json", "CONTENT_TYPE" => 'application/json'
|
|
|
|
music_session = JSON.parse(last_response.body)[0]
|
|
|
|
# and the creator should be in the session
|
|
music_session["participants"].length.should == 1
|
|
musician = music_session["participants"][0]
|
|
|
|
# and that musician should have the same IP address
|
|
musician["ip_address"].should == client.ip_address
|
|
|
|
# and that musician should have the correct IP address
|
|
musician["client_id"].should == client.client_id
|
|
|
|
# now delete that musician
|
|
delete "/api/participants/#{musician["client_id"]}.json", '', "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(204)
|
|
|
|
# re-fetch the session now that there is not a musician;
|
|
# we auto-delete sessions when the last person leaves
|
|
get "/api/sessions/#{music_session["id"]}.json"
|
|
last_response.status.should eql(404)
|
|
end
|
|
|
|
|
|
it "should add a second member to the session" do
|
|
|
|
user2 = FactoryGirl.create(:user)
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
client2 = FactoryGirl.create(:connection, :user => user2, :ip_address => "2.2.2.2")
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
# now fetch it's data
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id, }).to_json, "CONTENT_TYPE" => 'application/json'
|
|
|
|
get "/api/sessions.json", "CONTENT_TYPE" => 'application/json'
|
|
|
|
music_session = JSON.parse(last_response.body)[0]
|
|
|
|
# and the creator should be in the session
|
|
music_session["participants"].length.should == 1
|
|
musician = music_session["participants"][0]
|
|
# and should have tracks
|
|
musician["tracks"].length.should == 1
|
|
musician["tracks"][0]["instrument_id"].should == 'electric guitar'
|
|
musician["tracks"][0]["sound"].should == 'mono'
|
|
musician["ip_address"].should == client.ip_address
|
|
musician["client_id"].should == client.client_id
|
|
|
|
login(user2)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
# now fetch it's data
|
|
location_header = last_response.headers["Location"]
|
|
login(user2)
|
|
get location_header + ".json", "CONTENT_TYPE" => 'application/json'
|
|
|
|
#<<<<<<< HEAD
|
|
add_participant = JSON.parse(last_response.body)
|
|
#
|
|
# # is order safe to assume here? (2nd person in is 2nd participnat?)
|
|
participant = add_participant["participants"][1]
|
|
# # and the creator should be in the session
|
|
# # and should have tracks
|
|
#
|
|
#=======
|
|
# music_session = JSON.parse(last_response.body)
|
|
|
|
|
|
# and the second person should be in the session
|
|
# and should have tracks
|
|
# music_session["participants"].length.should == 2
|
|
# participant = music_session["participants"][1]
|
|
#>>>>>>> develop
|
|
participant["tracks"].length.should == 1
|
|
participant["tracks"][0]["instrument_id"].should == 'bass guitar'
|
|
participant["tracks"][0]["sound"].should == 'mono'
|
|
participant["ip_address"].should == client2.ip_address
|
|
participant["client_id"].should == client2.client_id
|
|
|
|
# refetch the session and make sure both participnats are accounted for
|
|
login(user2)
|
|
get "/api/sessions.json", "CONTENT_TYPE" => 'application/json'
|
|
|
|
music_session = JSON.parse(last_response.body)[0]
|
|
# and the creator should be in the session
|
|
music_session["participants"].length.should == 2
|
|
|
|
login(user)
|
|
delete "/api/participants/#{client.client_id}.json", '', "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(204)
|
|
login(user2)
|
|
delete "/api/participants/#{client2.client_id}.json", '', "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(204)
|
|
|
|
# re-fetch the session now that there is not a musician;
|
|
# we auto-delete sessions when the last person leaves
|
|
login(user2)
|
|
get "/api/sessions/#{music_session["id"]}.json"
|
|
last_response.status.should eql(404)
|
|
end
|
|
|
|
it "should error with no genre specified" do
|
|
# create the session
|
|
original_count = ActiveMusicSession.all().length
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions.json', defopts.merge({:genres => nil}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(422)
|
|
ActiveMusicSession.all().length.should == original_count
|
|
end
|
|
|
|
it "should error with invalid genre specified" do
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions.json', defopts.merge({:genres => ["Junk"]}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(422)
|
|
JSON.parse(last_response.body)["errors"]["genre"].should == ["can't be blank"]
|
|
end
|
|
|
|
it "should not error with no track specified" do
|
|
original_count = ActiveMusicSession.all().length
|
|
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client.client_id, :as_musician => true, :tracks => []}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
|
|
last_response.status.should eq(201)
|
|
end
|
|
|
|
it "should error with invalid track specified" do
|
|
original_count = ActiveMusicSession.all().length
|
|
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
# now fetch it's data
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants", defpart.merge({ :client_id => client.client_id, :tracks => [{"instrument_id" => "mom", "sound" => "mono", "client_track_id" => "client_track_guid"}] }).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(404)
|
|
|
|
# check that the transaction was rolled back
|
|
ActiveMusicSession.all().length.should == original_count
|
|
end
|
|
|
|
it "should error with invalid sound specified" do
|
|
original_count = ActiveMusicSession.all().length
|
|
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
# now fetch it's data
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mom", "client_track_id" => "client_track_guid"}] }).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(422)
|
|
|
|
# check that the transaction was rolled back
|
|
ActiveMusicSession.all().length.should == original_count
|
|
end
|
|
|
|
it "can see user_id of friend in session" do
|
|
pending
|
|
|
|
# create the session
|
|
user2 = FactoryGirl.create(:user) # in the music session
|
|
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id, :musician_access => false}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
session = JSON.parse(last_response.body)
|
|
|
|
FactoryGirl.create(:friendship, :user => user, :friend => user2)
|
|
FactoryGirl.create(:friendship, :user => user2, :friend => user)
|
|
|
|
login(user2)
|
|
get '/api/sessions.json'
|
|
last_response.status.should eql(200)
|
|
music_sessions = JSON.parse(last_response.body)
|
|
music_session = music_sessions[0]
|
|
|
|
music_session["id"].should == session["id"]
|
|
music_session["musician_access"].should == false
|
|
music_session["invitations"].should == []
|
|
music_session["participants"].length.should == 1
|
|
participant = music_session["participants"][0]
|
|
participant["ip_address"].should == client.ip_address
|
|
participant["client_id"].should == client.client_id
|
|
participant["user"]["id"].should == user.id
|
|
end
|
|
|
|
it "can see invitation_id associatied with hidden session" do
|
|
# create the session
|
|
user2 = FactoryGirl.create(:user) # in the music session
|
|
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
# now fetch it's data
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
get '/api/sessions.json'
|
|
last_response.status.should eql(200)
|
|
music_sessions = JSON.parse(last_response.body)
|
|
session = music_sessions[0]
|
|
|
|
FactoryGirl.create(:friendship, :user => user, :friend => user2)
|
|
FactoryGirl.create(:friendship, :user => user2, :friend => user)
|
|
invitation_model = FactoryGirl.create(:invitation, :sender => user, :receiver => user2, :music_session_id => session["id"] )
|
|
|
|
login(user2)
|
|
get '/api/sessions.json'
|
|
last_response.status.should eql(200)
|
|
music_sessions = JSON.parse(last_response.body)
|
|
music_session = music_sessions[0]
|
|
music_session["id"].should == session["id"]
|
|
music_session["musician_access"].should == true
|
|
|
|
# we should be able to see the invitation
|
|
music_session["invitations"].length.should == 1
|
|
invitation = music_session["invitations"][0]
|
|
invitation["id"].should == invitation_model.id
|
|
|
|
music_session["participants"].length.should == 1
|
|
participant = music_session["participants"][0]
|
|
participant["client_id"].should == client.client_id
|
|
|
|
# and see the user_id because they are friends
|
|
participant["user"]["id"].should == user.id
|
|
end
|
|
|
|
it "can't join closed music session with no invitation" do
|
|
# create the session
|
|
user2 = FactoryGirl.create(:user) # in the music session
|
|
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1", :client_id => "3")
|
|
login(user)
|
|
post '/api/sessions.json', defopts.merge({:musician_access => false}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
# now fetch it's data
|
|
music_session = JSON.parse(last_response.body)
|
|
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
session = JSON.parse(last_response.body)
|
|
|
|
client2 = FactoryGirl.create(:connection, :user => user2)
|
|
|
|
FactoryGirl.create(:friendship, :user => user, :friend => user2)
|
|
FactoryGirl.create(:friendship, :user => user2, :friend => user)
|
|
|
|
# users are friends, but no invitation... so we shouldn't be able to join as user 2
|
|
|
|
login(user2)
|
|
#<<<<<<< HEAD
|
|
# puts "SESSION #{session.inspect}"
|
|
post "/api/sessions/#{session["id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
#=======
|
|
# post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
#>>>>>>> develop
|
|
last_response.status.should eql(422)
|
|
join_response = JSON.parse(last_response.body)
|
|
join_response["errors"]["musician_access"].should == [ValidationMessages::INVITE_REQUIRED]
|
|
|
|
# but let's make sure if we then invite, that we can then join'
|
|
login(user)
|
|
#<<<<<<< HEAD
|
|
post '/api/invitations.json', { :music_session => session["id"], :receiver => user2.id }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
login(user2)
|
|
post "/api/sessions/#{session["id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}] }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
#=======
|
|
# post '/api/invitations.json', { :music_session => music_session["id"], :receiver => user2.id }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
# last_response.status.should eql(201)#
|
|
#
|
|
# login(user2)
|
|
# post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}] }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
#>>>>>>> develop
|
|
|
|
last_response.status.should eql(201)
|
|
end
|
|
|
|
it "join_requests don't show up in session listing" do
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
get '/api/sessions.json'
|
|
music_sessions = JSON.parse(last_response.body)
|
|
|
|
music_session = music_sessions[0]
|
|
music_session["id"].should == music_session["id"]
|
|
music_session["join_requests"].should == []
|
|
|
|
user2 = FactoryGirl.create(:user) # in the music session
|
|
|
|
login(user2)
|
|
|
|
# create join request
|
|
post '/api/join_requests.json', { :music_session => music_session["id"], :text => "lemme in" }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 201
|
|
|
|
location_header = last_response.headers["Location"]
|
|
login(user2)
|
|
get location_header + ".json", "CONTENT_TYPE" => 'application/json'
|
|
|
|
join_request = JSON.parse(last_response.body)
|
|
|
|
# now join_requests should still be empty, because we don't share join_requests to people outside the session
|
|
login(user2)
|
|
get '/api/sessions.json'
|
|
music_sessions = JSON.parse(last_response.body)
|
|
|
|
music_session = music_sessions[0]
|
|
music_session["id"].should == music_session["id"]
|
|
music_session["join_requests"].should be_nil
|
|
|
|
login(user)
|
|
|
|
# but for people in the session, they can see the join_requests!
|
|
get '/api/sessions.json'
|
|
music_sessions = JSON.parse(last_response.body)
|
|
|
|
music_session = music_sessions[0]
|
|
music_session["id"].should == music_session["id"]
|
|
music_session["join_requests"].length.should == 1
|
|
music_session["join_requests"][0]["id"].should == join_request["id"]
|
|
end
|
|
|
|
it "should allow join of teacher or student" do
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
teacher = FactoryGirl.create(:teacher_user)
|
|
lesson_session = normal_lesson(user, teacher)
|
|
|
|
|
|
music_session = lesson_session.music_session
|
|
|
|
music_session.musician_access.should be false
|
|
user2 = FactoryGirl.create(:user)
|
|
client2 = FactoryGirl.create(:connection, :user => user2, :ip_address => "2.2.2.2")
|
|
client3 = FactoryGirl.create(:connection, :user => teacher, :ip_address => "3.3.3.3")
|
|
|
|
login(user)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
|
|
login(user2)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(422)
|
|
rejected_join_attempt = JSON.parse(last_response.body)
|
|
rejected_join_attempt["errors"]["musician_access"] = [ValidationMessages::INVITE_REQUIRED]
|
|
|
|
login(teacher)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client3.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
end
|
|
|
|
it "should now allow join of approval_required=true session" do
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
|
|
post '/api/sessions.json', defopts.merge({:approval_required => true}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
music_session = JSON.parse(last_response.body)
|
|
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
get "/api/sessions.json"
|
|
music_sessions = JSON.parse(last_response.body)
|
|
music_sessions.length.should eq(1)
|
|
music_sessions[0]["id"] .should eq(music_session["id"])
|
|
|
|
# try to add 2nd user to session - should fail because approval is required
|
|
user2 = FactoryGirl.create(:user)
|
|
client2 = FactoryGirl.create(:connection, :user => user2, :ip_address => "2.2.2.2")
|
|
|
|
login(user2)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(422)
|
|
rejected_join_attempt = JSON.parse(last_response.body)
|
|
rejected_join_attempt["errors"]["approval_required"] = [ValidationMessages::INVITE_REQUIRED]
|
|
|
|
# now send up a join_request to try and get in
|
|
login(user2)
|
|
post '/api/join_requests.json', { :music_session => music_session["id"], :text => "lemme in" }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 201
|
|
|
|
join_request_id = JSON.parse(last_response.body)["id"]
|
|
login(user2)
|
|
get "/api/join_requests/#{join_request_id}.json", "CONTENT_TYPE" => 'application/json'
|
|
join_request = JSON.parse(last_response.body)
|
|
|
|
# pop back to user1 and allow user2 to get in
|
|
login(user)
|
|
|
|
post '/api/invitations.json', {:music_session => music_session["id"], :receiver => user2.id, :join_request => join_request["id"]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
# finally, go back to user2 and attempt to join again
|
|
login(user2)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
end
|
|
|
|
|
|
|
|
it "should allow create session and join session for creator" do
|
|
# this test was created to stop duplication of tracks
|
|
# but ultimately it should be fine to create a session, and then 'join' it with no ill effects
|
|
# https://jamkazam.atlassian.net/browse/VRFS-254
|
|
user.admin = true
|
|
client = FactoryGirl.create(:connection, :user => user)
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
get "/api/sessions.json"
|
|
music_session = JSON.parse(last_response.body)[0]
|
|
|
|
get "/api/sessions/#{music_session["id"]}.json"
|
|
last_response.status.should eql(200)
|
|
music_session["participants"].length.should == 1
|
|
participant = music_session["participants"][0]
|
|
participant["client_id"].should == client.client_id
|
|
participant["tracks"].length.should == 1
|
|
track = participant["tracks"][0]
|
|
track["instrument_id"].should == "electric guitar"
|
|
track["sound"].should == "mono"
|
|
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client.client_id, :as_musician => true, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
|
|
last_response.status.should eql(201)
|
|
|
|
get "/api/sessions/#{music_session["id"]}.json"
|
|
music_session = JSON.parse(last_response.body)
|
|
music_session["participants"].length.should == 1
|
|
participant = music_session["participants"][0]
|
|
participant["client_id"].should == client.client_id
|
|
participant["tracks"].length.should == 1 # there should only be one track, still
|
|
track = participant["tracks"][0]
|
|
track["instrument_id"].should == "electric guitar"
|
|
track["sound"].should == "mono"
|
|
end
|
|
|
|
it "can't join session that's recording" do
|
|
user = FactoryGirl.create(:user)
|
|
user2 = FactoryGirl.create(:user)
|
|
client = FactoryGirl.create(:connection, :user => user)
|
|
client2 = FactoryGirl.create(:connection, :user => user2)
|
|
instrument = FactoryGirl.create(:instrument, :description => 'a great instrument')
|
|
track = FactoryGirl.create(:track, :connection => client, :instrument => instrument)
|
|
track2 = FactoryGirl.create(:track, :connection => client2, :instrument => instrument)
|
|
|
|
# 1st user joins
|
|
login(user)
|
|
post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
|
|
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
get "/api/sessions.json"
|
|
music_session = JSON.parse(last_response.body)[0]
|
|
|
|
# start a recording
|
|
post "/api/recordings/start", {:format => :json, :music_session_id => music_session['id'], record_video:false }.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
# user 2 should not be able to join
|
|
login(user2)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(422)
|
|
JSON.parse(last_response.body)["errors"]["music_session"][0].should == ValidationMessages::CANT_JOIN_RECORDING_SESSION
|
|
end
|
|
|
|
it "shows mount info based on fan_access" do
|
|
# create the session
|
|
server = FactoryGirl.create(:icecast_server_minimal)
|
|
user2 = FactoryGirl.create(:user) # in the music session
|
|
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.10", :client_id => "mount_info")
|
|
post '/api/sessions.json', defopts.merge({:fan_access => true}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
music_session = JSON.parse(last_response.body)
|
|
post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should eql(201)
|
|
|
|
get "/api/sessions.json"
|
|
session = JSON.parse(last_response.body)[0]
|
|
|
|
music_session = ActiveMusicSession.find(session["id"])
|
|
session["mount"].should_not be_nil
|
|
session["mount"]["name"].should == music_session.mount.name
|
|
session["mount"]["listeners"].should == music_session.mount.listeners
|
|
session["mount"]["sourced"].should == music_session.mount.sourced
|
|
|
|
# set gfan_access to false, which should cause the mount info to hide
|
|
music_session.music_session.fan_access = false
|
|
music_session.music_session.save!
|
|
|
|
get "/api/sessions/#{session["id"]}.json"
|
|
last_response.status.should eql(200)
|
|
session = JSON.parse(last_response.body)
|
|
session["mount"].should be_nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
it "Finds a single open session" do
|
|
creator = FactoryGirl.create(:user)
|
|
session = FactoryGirl.create(:active_music_session, :creator => creator, :description => "My Session")
|
|
client = FactoryGirl.create(:connection, :user => creator, :music_session => session)
|
|
|
|
user = FactoryGirl.create(:user)
|
|
login(user)
|
|
|
|
get '/api/sessions', "CONTENT_TYPE" => "application/json"
|
|
last_response.status.should == 200
|
|
sessions = JSON.parse(last_response.body)
|
|
sessions.length.should == 1
|
|
sessions.first["description"].should == "My Session"
|
|
end
|
|
|
|
it "prepare for perf data upload" do
|
|
user = FactoryGirl.create(:user)
|
|
client = FactoryGirl.create(:connection, :user => user)
|
|
music_session = FactoryGirl.create(:active_music_session, :creator => user, :description => "My Session")
|
|
msuh = FactoryGirl.create(:music_session_user_history, :music_session_id => music_session.id, :client_id => client.client_id, :user_id => user.id)
|
|
|
|
put "/api/sessions/#{music_session.id}/perf.json?client_id=#{client.client_id}", "CONTENT_TYPE" => "application/json"
|
|
|
|
last_response.status.should == 302
|
|
redirect = last_response.headers["Location"]
|
|
|
|
put redirect + '.json', "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 200
|
|
body = JSON.parse(last_response.body)
|
|
perf_data_id = body["id"]
|
|
|
|
music_session_perf_data = MusicSessionPerfData.find(perf_data_id)
|
|
music_session_perf_data.should_not be_nil
|
|
music_session_perf_data.music_session_user_history.should == MusicSessionUserHistory.find_by_client_id(client.client_id)
|
|
end
|
|
|
|
it "rating" do
|
|
user = FactoryGirl.create(:user)
|
|
client = FactoryGirl.create(:connection, :user => user)
|
|
music_session = FactoryGirl.create(:active_music_session, :creator => user, :description => "My Session")
|
|
msuh = FactoryGirl.create(:music_session_user_history, :music_session_id => music_session.id, :client_id => client.client_id, :user_id => user.id)
|
|
msuh.rating.should be_nil
|
|
login(user)
|
|
post "/api/participant_histories/#{msuh.client_id}/rating.json", { :rating => 1 }.to_json, "CONTENT_TYPE" => "application/json"
|
|
last_response.status.should == 200
|
|
msuh.reload
|
|
msuh.rating.to_i.should == 1
|
|
end
|
|
|
|
it "track sync" do
|
|
pending "recording_session_landing broken tests"
|
|
user = FactoryGirl.create(:single_user_session)
|
|
instrument = FactoryGirl.create(:instrument, :description => 'a great instrument')
|
|
music_session = FactoryGirl.create(:active_music_session, :creator => user)
|
|
client = FactoryGirl.create(:connection, :user => user, :music_session => music_session)
|
|
track = FactoryGirl.create(:track, :connection => client, :instrument => instrument)
|
|
|
|
existing_track = {:id => track.id, :client_track_id => track.client_track_id, :sound => track.sound, :instrument_id => track.instrument_id }
|
|
new_track = {:client_track_id => "client_track_id1", :instrument_id => instrument.id, :sound => 'stereo'}
|
|
# let's add a new track, and leave the existing one alone
|
|
tracks = [existing_track, new_track]
|
|
login(user)
|
|
|
|
put "/api/sessions/#{music_session.id}/tracks.json", { :client_id => client.client_id, :tracks => tracks }.to_json, "CONTENT_TYPE" => "application/json"
|
|
last_response.status.should == 204
|
|
|
|
get "/api/sessions/#{music_session.id}/tracks.json", "CONTENT_TYPE" => 'application/json'
|
|
last_response.status.should == 200
|
|
tracks = JSON.parse(last_response.body)
|
|
tracks.size.should == 2
|
|
tracks[0]["id"].should == track.id
|
|
tracks[0]["instrument_id"].should == instrument.id
|
|
tracks[0]["sound"].should == "mono"
|
|
tracks[0]["client_track_id"].should == track.client_track_id
|
|
tracks[1]["instrument_id"].should == instrument.id
|
|
tracks[1]["sound"].should == "stereo"
|
|
tracks[1]["client_track_id"].should == "client_track_id1"
|
|
end
|
|
|
|
it "allows start/stop recording playback of a claimed recording" do
|
|
|
|
user = FactoryGirl.create(:user)
|
|
connection = FactoryGirl.create(:connection, :user => user)
|
|
track = FactoryGirl.create(:track, :connection => connection, :instrument => Instrument.first)
|
|
music_session = FactoryGirl.create(:active_music_session, :creator => user, :musician_access => true)
|
|
# music_session.connections << connection
|
|
music_session.save
|
|
connection.join_the_session(music_session, true, nil, user, 10)
|
|
recording = Recording.start(music_session, user)
|
|
recording.stop
|
|
recording.reload
|
|
claimed_recording = recording.claim(user, "name", "description", Genre.first, true)
|
|
recording.reload
|
|
|
|
login(user)
|
|
post "/api/sessions/#{music_session.id}/claimed_recording/#{claimed_recording.id}/start.json", {}.to_json, "CONTENT_TYPE" => "application/json"
|
|
|
|
last_response.status.should == 201
|
|
music_session.reload
|
|
music_session.claimed_recording.should == claimed_recording
|
|
music_session.claimed_recording_initiator.should == user
|
|
|
|
post "/api/sessions/#{music_session.id}/claimed_recording/#{claimed_recording.id}/stop.json", {}.to_json, "CONTENT_TYPE" => "application/json"
|
|
|
|
last_response.status.should == 201
|
|
music_session.reload
|
|
music_session.claimed_recording.should be_nil
|
|
music_session.claimed_recording_initiator.should be_nil
|
|
end
|
|
end |