+ 
-
+
+
-
+
+
-
+
+
-
+
+
-
+
+
+
-
+
-
+
-
+
I'm interested in forming virtual band(s)
diff --git a/web/app/views/clients/_session.html.slim b/web/app/views/clients/_session.html.slim
index 7a79b81fd..49a5b2cb0 100644
--- a/web/app/views/clients/_session.html.slim
+++ b/web/app/views/clients/_session.html.slim
@@ -71,7 +71,7 @@
| other audio
.session-recording-name-wrapper
.session-recording-name.left
- | (No recording loaded)
+ | (No audio loaded)
.session-add.right
a#close-playback-recording[href="#"]
= image_tag "content/icon_close.png", {:width => 18, :height => 20, :align => "texttop"}
diff --git a/web/app/views/clients/index.html.erb b/web/app/views/clients/index.html.erb
index 94af76504..7586d0e9b 100644
--- a/web/app/views/clients/index.html.erb
+++ b/web/app/views/clients/index.html.erb
@@ -64,6 +64,7 @@
<%= render "overlay_small" %>
<%= render "listenBroadcast" %>
<%= render "sync_viewer_templates" %>
+<%= render "download_jamtrack_templates" %>
<%= render "help" %>
<%= render 'dialogs/dialogs' %>
diff --git a/web/app/views/dialogs/_openJamTrackDialog.html.slim b/web/app/views/dialogs/_openJamTrackDialog.html.slim
index 18ca215a7..2e5ec5f7c 100644
--- a/web/app/views/dialogs/_openJamTrackDialog.html.slim
+++ b/web/app/views/dialogs/_openJamTrackDialog.html.slim
@@ -31,7 +31,7 @@
a href='/client#/jamtrack' rel="external"
| Shop for JamTracks
.right
- a href="#" class="button-grey" layout-action="close"
+ a href="#" class="button-grey" layout-action="cancel"
| CANCEL
diff --git a/web/app/views/spikes/download_jam_track.html.slim b/web/app/views/spikes/download_jam_track.html.slim
new file mode 100644
index 000000000..ade3744b5
--- /dev/null
+++ b/web/app/views/spikes/download_jam_track.html.slim
@@ -0,0 +1,44 @@
+= javascript_include_tag "download_jamtrack"
+= render "clients/download_jamtrack_templates"
+= stylesheet_link_tag "client/downloadJamTrack"
+
+- provide(:title, 'Download Jam Track Widget')
+
+.content-wrapper
+ h2 Jam Track State Widget
+
+ h3 Possible States
+ ul
+ li synchronized
+ li no_client
+ li packaging
+ li downloading
+ li keying
+ li initial
+ li errored
+ #widget
+
+javascript:
+ var initialized = false;
+ $(document).on('JAMKAZAM_READY', function(e, data) {
+ window.JK.JamServer.get$Server().on(window.JK.EVENTS.CONNECTION_UP, function() {
+ if(initialized) {
+ return;
+ }
+ initialized = true
+
+ setTimeout(function() {
+ window.downloadJamTrack = new JK.DownloadJamTrack(data.app, {id: gon.jamTrackId, jam_track_right_id: gon.jamTrackRightId, name: 'Back in Black'}, gon.size)
+ downloadJamTrack.init()
+ $('#widget').append(window.downloadJamTrack.root)
+
+ if (gon.switchState == 'errored') {
+ downloadJamTrack.transitionError("package-error", "The server failed to create your package.")
+ }
+ else if (gon.switchState) {
+ downloadJamTrack.transition(downloadJamTrack.states[gon.switchState]);
+ }
+ }, 1)
+
+ })
+ })
\ No newline at end of file
diff --git a/web/config/application.rb b/web/config/application.rb
index 687b93ff4..2ec535647 100644
--- a/web/config/application.rb
+++ b/web/config/application.rb
@@ -209,6 +209,8 @@ if defined?(Bundler)
# Location of jamtracks python tool:
config.jamtracks_dir = ENV['JAMTRACKS_DIR'] || File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "jamtracks"))
+ config.jmep_dir = ENV['JMEP_DIR'] || File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "jmep"))
+
# amount of time before we think packaging job is broken
config.signing_job_run_max_time = 60 # 1 minute
# amount of time before we think the queue is stuck
@@ -310,6 +312,7 @@ if defined?(Bundler)
config.influxdb_port = 8086
config.influxdb_ignored_environments = ENV["INFLUXDB_ENABLED"] == '1' ? ['test', 'cucumber'] : ['test', 'cucumber', 'development']
+ config.allow_spikes = false
config.show_jamblaster_notice = true
config.show_jamblaster_kickstarter_link = true
config.metronome_available = true
diff --git a/web/config/routes.rb b/web/config/routes.rb
index cf13dfc6f..e1030964a 100644
--- a/web/config/routes.rb
+++ b/web/config/routes.rb
@@ -81,21 +81,20 @@ SampleApp::Application.routes.draw do
match '/endorse/:id/:service', to: 'users#endorse', :as => 'endorse'
- # temporarily allow for debugging--only allows admini n
- match '/listen_in', to: 'spikes#listen_in'
-
# embed resque-web if this is development mode
- if Rails.env == "development"
+ if Rails.env == "development" || Rails.application.config.allow_spikes
require 'resque/server'
require 'resque-retry'
require 'resque-retry/server'
mount Resque::Server.new, :at => "/resque" if Rails.env == "development"
# route to spike controller (proof-of-concepts)
+ match '/listen_in', to: 'spikes#listen_in'
match '/facebook_invite', to: 'spikes#facebook_invite'
match '/launch_app', to: 'spikes#launch_app'
match '/websocket', to: 'spikes#websocket'
match '/test_subscription', to: 'spikes#subscription'
+ match '/widgets/download_jam_track', to: 'spikes#download_jam_track'
match '/site_validate', to: 'spikes#site_validate'
match '/recording_source', to: 'spikes#recording_source'
@@ -210,7 +209,7 @@ SampleApp::Application.routes.draw do
match '/jamtracks/downloads' => 'api_jam_tracks#downloads', :via => :get, :as => 'api_jam_tracks_downloads'
match '/jamtracks/download/:id' => 'api_jam_tracks#download', :via => :get, :as => 'api_jam_tracks_download'
match '/jamtracks/enqueue/:id' => 'api_jam_tracks#enqueue', :via => :post, :as => 'api_jam_tracks_enqueue'
- match '/jamtracks/show/:id' => 'api_jam_tracks#show_jam_track_right', :via => :get, :as => 'api_jam_tracks_show_right'
+ match '/jamtracks/rights/:id' => 'api_jam_tracks#show_jam_track_right', :via => :get, :as => 'api_jam_tracks_show_right'
match '/jamtracks/keys' => 'api_jam_tracks#keys', :via => :post, :as => 'api_jam_tracks_keys'
# Shopping carts
@@ -456,6 +455,7 @@ SampleApp::Application.routes.draw do
match '/recordings/:id/comments' => 'api_recordings#add_comment', :via => :post, :as => 'api_recordings_add_comment'
match '/recordings/:id/likes' => 'api_recordings#add_like', :via => :post, :as => 'api_recordings_add_like'
match '/recordings/:id/discard' => 'api_recordings#discard', :via => :post, :as => 'api_recordings_discard'
+ match '/recordings/:id/timeline' => 'api_recordings#add_timeline', :via => :post, :as => 'api_recordings_timeline'
# Recordings - recorded_tracks
match '/recordings/:id/tracks/:track_id' => 'api_recordings#show_recorded_track', :via => :get, :as => 'api_recordings_show_recorded_track'
diff --git a/web/lib/tasks/sample_data.rake b/web/lib/tasks/sample_data.rake
index 853194455..c19d46dea 100644
--- a/web/lib/tasks/sample_data.rake
+++ b/web/lib/tasks/sample_data.rake
@@ -1,6 +1,6 @@
require 'factory_girl'
require 'open-uri'
-
+#require './spec/factories.rb' # useful when run on a server
namespace :db do
desc "Add a simple one track recording to the database"
diff --git a/web/spec/controllers/api_jam_tracks_controller_spec.rb b/web/spec/controllers/api_jam_tracks_controller_spec.rb
index 31101592c..f22fb23f9 100644
--- a/web/spec/controllers/api_jam_tracks_controller_spec.rb
+++ b/web/spec/controllers/api_jam_tracks_controller_spec.rb
@@ -101,6 +101,7 @@ describe ApiJamTracksController do
response.should be_success
json = JSON.parse(response.body)
json['jamtracks'].length.should eq(1)
+ json['jamtracks'][0]['jam_track_right_id'].should eq(right.id)
json['next'].should be_nil
end
end
@@ -157,18 +158,18 @@ describe ApiJamTracksController do
describe "keys" do
it "empty" do
- get :keys, jamtracks: []
+ get :keys, jamtracks: {tracks: []}
response.status.should == 200
json = JSON.parse(response.body)
json.length == 0
end
it "track with no rights" do
- get :keys, jamtracks: [@jam_track.id]
+ get :keys, jamtracks: { tracks: [@jam_track.id] }
response.status.should == 200
json = JSON.parse(response.body)
json.length.should == 1
- json[0]['id'].should == @jam_track.id
+ json[0]['id'].should == @jam_track.id.to_s
json[0]['private'].should be_nil
json[0]['error'].should == 'not_purchased'
end
@@ -177,32 +178,32 @@ describe ApiJamTracksController do
right = FactoryGirl.create(:jam_track_right, user: @user, private_key: nil, jam_track: @jam_track)
- get :keys, jamtracks: [@jam_track.id]
+ get :keys, jamtracks: { tracks: [@jam_track.id] }
response.status.should == 200
json = JSON.parse(response.body)
json.length.should == 1
- json[0]['id'].should == @jam_track.id
+ json[0]['id'].should == @jam_track.id.to_s
json[0]['private'].should be_nil
json[0]['error'].should == 'no_key'
end
it "track with key" do
right = FactoryGirl.create(:jam_track_right, user: @user, private_key: 'abc', jam_track: @jam_track)
- get :keys, jamtracks: [@jam_track.id]
+ get :keys, jamtracks: { tracks: [@jam_track.id] }
response.status.should == 200
json = JSON.parse(response.body)
json.length.should == 1
- json[0]['id'].should == @jam_track.id
+ json[0]['id'].should == @jam_track.id.to_s
json[0]['private'].should eq('abc')
json[0]['error'].should be_nil
end
it "non-owning user asking for a real track" do
right = FactoryGirl.create(:jam_track_right, user: FactoryGirl.create(:user), private_key: 'abc', jam_track: @jam_track)
- get :keys, jamtracks: [@jam_track.id]
+ get :keys, jamtracks: { tracks: [@jam_track.id] }
response.status.should == 200
json = JSON.parse(response.body)
- json[0]['id'].should == @jam_track.id
+ json[0]['id'].should == @jam_track.id.to_s
json[0]['private'].should be_nil
json[0]['error'].should == 'not_purchased'
end
diff --git a/web/spec/controllers/api_recordings_controller_spec.rb b/web/spec/controllers/api_recordings_controller_spec.rb
index f09a6130d..ac54f6272 100644
--- a/web/spec/controllers/api_recordings_controller_spec.rb
+++ b/web/spec/controllers/api_recordings_controller_spec.rb
@@ -3,217 +3,251 @@ require 'spec_helper'
describe ApiRecordingsController do
render_views
+ describe "recording with backing track" do
- before(:each) do
- @user = FactoryGirl.create(:user)
- @instrument = FactoryGirl.create(:instrument, :description => 'a great instrument')
- @music_session = FactoryGirl.create(:active_music_session, :creator => @user, :musician_access => true)
- @connection = FactoryGirl.create(:connection, :user => @user, :music_session => @music_session)
- @track = FactoryGirl.create(:track, :connection => @connection, :instrument => @instrument)
- @backing_track = FactoryGirl.create(:backing_track, :connection => @connection)
- controller.current_user = @user
- end
-
- describe "start" do
- it "should work" do
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response.should be_success
- response_body = JSON.parse(response.body)
- response_body['id'].should_not be_nil
- recording = Recording.find(response_body['id'])
+ before(:each) do
+ @user = FactoryGirl.create(:user)
+ @instrument = FactoryGirl.create(:instrument, :description => 'a great instrument')
+ @music_session = FactoryGirl.create(:active_music_session, :creator => @user, :musician_access => true)
+ @connection = FactoryGirl.create(:connection, :user => @user, :music_session => @music_session)
+ @track = FactoryGirl.create(:track, :connection => @connection, :instrument => @instrument)
+ @backing_track = FactoryGirl.create(:backing_track, :connection => @connection)
+ controller.current_user = @user
end
- it "should not allow multiple starts" do
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response.status.should == 422
- response_body = JSON.parse(response.body)
- response_body["errors"]["music_session"][0].should == ValidationMessages::ALREADY_BEING_RECORDED
+ describe "start" do
+ it "should work" do
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response.should be_success
+ response_body = JSON.parse(response.body)
+ response_body['id'].should_not be_nil
+ recording = Recording.find(response_body['id'])
+ end
+
+ it "should not allow multiple starts" do
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response.status.should == 422
+ response_body = JSON.parse(response.body)
+ response_body["errors"]["music_session"][0].should == ValidationMessages::ALREADY_BEING_RECORDED
+ end
+
+ it "should not allow start while playback ongoing" do
+ recording = Recording.start(@music_session, @user)
+ recording.stop
+ recording.reload
+ claimed_recording = recording.claim(@user, "name", "description", Genre.first, true)
+ @music_session.claimed_recording_start(@user, claimed_recording)
+ @music_session.errors.any?.should be_false
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response.status.should == 422
+ response_body = JSON.parse(response.body)
+ response_body["errors"]["music_session"][0].should == ValidationMessages::ALREADY_PLAYBACK_RECORDING
+ end
+
+ it "should not allow start by somebody not in the music session" do
+ user2 = FactoryGirl.create(:user)
+ controller.current_user = user2
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response.status.should == 403
+ end
end
- it "should not allow start while playback ongoing" do
- recording = Recording.start(@music_session, @user)
- recording.stop
- recording.reload
- claimed_recording = recording.claim(@user, "name", "description", Genre.first, true)
- @music_session.claimed_recording_start(@user, claimed_recording)
- @music_session.errors.any?.should be_false
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response.status.should == 422
- response_body = JSON.parse(response.body)
- response_body["errors"]["music_session"][0].should == ValidationMessages::ALREADY_PLAYBACK_RECORDING
+ describe "get" do
+ it "should work" do
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response.should be_success
+ response_body = JSON.parse(response.body)
+ response_body['id'].should_not be_nil
+ recordingId = response_body['id']
+ get :show, {:format => 'json', :id => recordingId}
+ response.should be_success
+ response_body = JSON.parse(response.body)
+ response_body['id'].should == recordingId
+ end
+
end
- it "should not allow start by somebody not in the music session" do
- user2 = FactoryGirl.create(:user)
- controller.current_user = user2
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response.status.should == 403
+ describe "stop" do
+ it "should work" do
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response_body = JSON.parse(response.body)
+ recording = Recording.find(response_body['id'])
+ post :stop, {:format => 'json', :id => recording.id}
+ response.should be_success
+ response_body = JSON.parse(response.body)
+ response_body['id'].should_not be_nil
+ Recording.find(response_body['id']).id.should == recording.id
+ end
+
+ it "should not allow stop on a session not being recorded" do
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response_body = JSON.parse(response.body)
+ recording = Recording.find(response_body['id'])
+ post :stop, {:format => 'json', :id => recording.id}
+ post :stop, {:format => 'json', :id => recording.id}
+ response.status.should == 422
+ response_body = JSON.parse(response.body)
+ end
+
+ it "should not allow stop on a session requested by a different member" do
+
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response_body = JSON.parse(response.body)
+ recording = Recording.find(response_body['id'])
+ user2 = FactoryGirl.create(:user)
+ controller.current_user = user2
+ post :stop, {:format => 'json', :id => recording.id}
+ response.status.should == 403
+ end
+ end
+
+ describe "download track" do
+ let(:mix) { FactoryGirl.create(:mix) }
+
+ it "should only allow a user to download a track if they have claimed the recording" do
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response_body = JSON.parse(response.body)
+ recording = Recording.find(response_body['id'])
+ post :stop, {:format => 'json', :id => recording.id}
+ response.should be_success
+ end
+
+
+ it "is possible" do
+ mix.touch
+ recorded_track = mix.recording.recorded_tracks[0]
+ controller.current_user = mix.recording.owner
+ get :download, {id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
+ response.status.should == 302
+
+ recorded_track.reload
+ recorded_track.download_count.should == 1
+
+ get :download, {id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
+ response.status.should == 302
+
+ recorded_track.reload
+ recorded_track.download_count.should == 2
+ end
+
+
+ it "prevents download after limit is reached" do
+ mix.touch
+ recorded_track = mix.recording.recorded_tracks[0]
+ recorded_track.download_count = APP_CONFIG.max_audio_downloads
+ recorded_track.save!
+ controller.current_user = recorded_track.user
+ get :download, {format: 'json', id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
+ response.status.should == 404
+ JSON.parse(response.body, symbolize_names: true)[:message].should == "download limit surpassed"
+ end
+
+
+ it "lets admins surpass limit" do
+ mix.touch
+ recorded_track = mix.recording.recorded_tracks[0]
+ recorded_track.download_count = APP_CONFIG.max_audio_downloads
+ recorded_track.save!
+ recorded_track.user.admin = true
+ recorded_track.user.save!
+
+ controller.current_user = recorded_track.user
+ get :download, {format: 'json', id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
+ response.status.should == 302
+ recorded_track.reload
+ recorded_track.download_count.should == 101
+ end
+ end
+
+ describe "download backing track" do
+ let(:mix) { FactoryGirl.create(:mix) }
+
+ it "should only allow a user to download a track if they have claimed the recording" do
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response_body = JSON.parse(response.body)
+ recording = Recording.find(response_body['id'])
+ post :stop, {:format => 'json', :id => recording.id}
+ response.should be_success
+ end
+
+
+ it "is possible" do
+ mix.touch
+ recorded_track = mix.recording.recorded_tracks[0]
+ controller.current_user = mix.recording.owner
+ get :download, {id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
+ response.status.should == 302
+
+ recorded_track.reload
+ recorded_track.download_count.should == 1
+
+ get :download, {id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
+ response.status.should == 302
+
+ recorded_track.reload
+ recorded_track.download_count.should == 2
+ end
+
+
+ it "prevents download after limit is reached" do
+ mix.touch
+ recorded_track = mix.recording.recorded_tracks[0]
+ recorded_track.download_count = APP_CONFIG.max_audio_downloads
+ recorded_track.save!
+ controller.current_user = recorded_track.user
+ get :download, {format: 'json', id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
+ response.status.should == 404
+ JSON.parse(response.body, symbolize_names: true)[:message].should == "download limit surpassed"
+ end
+
+
+ it "lets admins surpass limit" do
+ mix.touch
+ recorded_track = mix.recording.recorded_tracks[0]
+ recorded_track.download_count = APP_CONFIG.max_audio_downloads
+ recorded_track.save!
+ recorded_track.user.admin = true
+ recorded_track.user.save!
+
+ controller.current_user = recorded_track.user
+ get :download, {format: 'json', id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
+ response.status.should == 302
+ recorded_track.reload
+ recorded_track.download_count.should == 101
+ end
end
end
- describe "get" do
- it "should work" do
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response.should be_success
- response_body = JSON.parse(response.body)
- response_body['id'].should_not be_nil
- recordingId = response_body['id']
- get :show, {:format => 'json', :id => recordingId}
- response.should be_success
- response_body = JSON.parse(response.body)
- response_body['id'].should == recordingId
+ describe "recording with jam track" do
+
+ before(:each) do
+ @user = FactoryGirl.create(:user)
+ @instrument = FactoryGirl.create(:instrument, :description => 'a great instrument')
+ @music_session = FactoryGirl.create(:active_music_session, :creator => @user, :musician_access => true)
+ @connection = FactoryGirl.create(:connection, :user => @user, :music_session => @music_session)
+ @track = FactoryGirl.create(:track, :connection => @connection, :instrument => @instrument)
+ @jam_track = FactoryGirl.create(:jam_track)
+
+ # make sure the jam track is opened
+ @music_session.jam_track = @jam_track
+ @music_session.jam_track_initiator = @user
+ @music_session.save!
+ controller.current_user = @user
end
- end
-
- describe "stop" do
- it "should work" do
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response_body = JSON.parse(response.body)
- recording = Recording.find(response_body['id'])
- post :stop, { :format => 'json', :id => recording.id }
- response.should be_success
- response_body = JSON.parse(response.body)
- response_body['id'].should_not be_nil
- Recording.find(response_body['id']).id.should == recording.id
- end
-
- it "should not allow stop on a session not being recorded" do
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response_body = JSON.parse(response.body)
- recording = Recording.find(response_body['id'])
- post :stop, { :format => 'json', :id => recording.id }
- post :stop, { :format => 'json', :id => recording.id }
- response.status.should == 422
- response_body = JSON.parse(response.body)
- end
-
- it "should not allow stop on a session requested by a different member" do
-
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response_body = JSON.parse(response.body)
- recording = Recording.find(response_body['id'])
- user2 = FactoryGirl.create(:user)
- controller.current_user = user2
- post :stop, { :format => 'json', :id => recording.id }
- response.status.should == 403
- end
- end
-
- describe "download track" do
- let(:mix) { FactoryGirl.create(:mix) }
-
- it "should only allow a user to download a track if they have claimed the recording" do
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response_body = JSON.parse(response.body)
- recording = Recording.find(response_body['id'])
- post :stop, { :format => 'json', :id => recording.id }
- response.should be_success
- end
-
-
- it "is possible" do
- mix.touch
- recorded_track = mix.recording.recorded_tracks[0]
- controller.current_user = mix.recording.owner
- get :download, {id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
- response.status.should == 302
-
- recorded_track.reload
- recorded_track.download_count.should == 1
-
- get :download, {id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
- response.status.should == 302
-
- recorded_track.reload
- recorded_track.download_count.should == 2
- end
-
-
- it "prevents download after limit is reached" do
- mix.touch
- recorded_track = mix.recording.recorded_tracks[0]
- recorded_track.download_count = APP_CONFIG.max_audio_downloads
- recorded_track.save!
- controller.current_user = recorded_track.user
- get :download, {format:'json', id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
- response.status.should == 404
- JSON.parse(response.body, symbolize_names: true)[:message].should == "download limit surpassed"
- end
-
-
- it "lets admins surpass limit" do
- mix.touch
- recorded_track = mix.recording.recorded_tracks[0]
- recorded_track.download_count = APP_CONFIG.max_audio_downloads
- recorded_track.save!
- recorded_track.user.admin = true
- recorded_track.user.save!
-
- controller.current_user = recorded_track.user
- get :download, {format:'json', id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
- response.status.should == 302
- recorded_track.reload
- recorded_track.download_count.should == 101
- end
- end
-
- describe "download backing track" do
- let(:mix) { FactoryGirl.create(:mix) }
-
- it "should only allow a user to download a track if they have claimed the recording" do
- post :start, { :format => 'json', :music_session_id => @music_session.id }
- response_body = JSON.parse(response.body)
- recording = Recording.find(response_body['id'])
- post :stop, { :format => 'json', :id => recording.id }
- response.should be_success
- end
-
-
- it "is possible" do
- mix.touch
- recorded_track = mix.recording.recorded_tracks[0]
- controller.current_user = mix.recording.owner
- get :download, {id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
- response.status.should == 302
-
- recorded_track.reload
- recorded_track.download_count.should == 1
-
- get :download, {id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
- response.status.should == 302
-
- recorded_track.reload
- recorded_track.download_count.should == 2
- end
-
-
- it "prevents download after limit is reached" do
- mix.touch
- recorded_track = mix.recording.recorded_tracks[0]
- recorded_track.download_count = APP_CONFIG.max_audio_downloads
- recorded_track.save!
- controller.current_user = recorded_track.user
- get :download, {format:'json', id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
- response.status.should == 404
- JSON.parse(response.body, symbolize_names: true)[:message].should == "download limit surpassed"
- end
-
-
- it "lets admins surpass limit" do
- mix.touch
- recorded_track = mix.recording.recorded_tracks[0]
- recorded_track.download_count = APP_CONFIG.max_audio_downloads
- recorded_track.save!
- recorded_track.user.admin = true
- recorded_track.user.save!
-
- controller.current_user = recorded_track.user
- get :download, {format:'json', id: recorded_track.recording.id, track_id: recorded_track.client_track_id}
- response.status.should == 302
- recorded_track.reload
- recorded_track.download_count.should == 101
+ describe "start" do
+ it "should work" do
+ post :start, {:format => 'json', :music_session_id => @music_session.id}
+ response.should be_success
+ response_body = JSON.parse(response.body)
+ response_body['id'].should_not be_nil
+ recording = Recording.find(response_body['id'])
+ recorded_jam_track_track = response_body["recorded_jam_track_tracks"][0]
+ recorded_jam_track_track["id"].should eq(@jam_track.jam_track_tracks[0].id)
+ recorded_jam_track_track["timeline"].should eq([])
+ end
end
end
end
+
diff --git a/web/spec/javascripts/download_jamtrack_spec.js.coffee b/web/spec/javascripts/download_jamtrack_spec.js.coffee
index b98150477..4c358b324 100644
--- a/web/spec/javascripts/download_jamtrack_spec.js.coffee
+++ b/web/spec/javascripts/download_jamtrack_spec.js.coffee
@@ -1,16 +1,310 @@
describe "DownloadJamTrack", ->
beforeEach ->
- this.fixtures = fixture.load("downoadJamTrack.html", "user_sync_track1.json"); # append these fixtures which were already cached
- this.server = sinon.fakeServer.create();
+ this.fixtures = fixture.load("downloadJamTrack.html"); # append these fixtures which were already cached
window.jamClient = sinon.stub()
- this.downloadJamTrack = new JK.DownloadJamTrack()
- this.downloadJamTrack.init()
- $('body').append(this.downloadJamTrack.root)
+ this.app = sinon.stub()
+ this.jamTrackId = '1'
+ this.jamTrack = {id: this.jamTrackId, jam_track_right_id: '1', name: 'Back in Black', version:'1'}
+ window.gon = {}
+ window.JK.JamServer = {}
+ window.stats = {}
+ @statsSpy = window.stats.write = sinon.spy()
+ window.JK.JamServer.send = sinon.stub(); # attempts to subscribe to the socket will need this
afterEach ->
- this.server.restore();
+ window.stats.write.reset()
+
+ describe "normal browser", ->
+
+ beforeEach ->
+ window.gon.isNativeClient = false
+ @showNoClientSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showNoClient')
+ @downloadJamTrack = new JK.DownloadJamTrack(@app, @jamTrack)
+ $('body').append(this.downloadJamTrack.root)
+
+ afterEach ->
+ @showNoClientSpy.restore()
+
+ it "switches to 'no client' correctly", ->
+ window.jamClient.JamTrackGetTrackDetail = sinon.stub()
+ window.jamClient.InvalidateJamTrack = sinon.stub()
+ #window.jamClient.JamTrackGetTrackDetail.returns({'key_state' : 'ready'})
+
+ @downloadJamTrack.init();
+
+ expect(window.jamClient.JamTrackGetTrackDetail.callCount).toBe(0)
+ expect(@showNoClientSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.stateHolder.find('.state-no-client')).toHaveLength(1)
+ expect(@statsSpy.calledOnce).toBe(true)
+
+ describe "client", ->
+
+ beforeEach ->
+ window.gon.isNativeClient = true
+
+ describe "already synchronized", ->
+ beforeEach ->
+ @showSynchronizedSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showSynchronized')
+ @downloadJamTrack = new JK.DownloadJamTrack(@app, @jamTrack)
+ $('body').append(@downloadJamTrack.root)
+
+ afterEach ->
+ @showSynchronizedSpy.restore()
+ @downloadJamTrack.destroy()
+
+ it "shows synchronized state", ->
+ window.jamClient.JamTrackGetTrackDetail = sinon.stub()
+ window.jamClient.JamTrackGetTrackDetail.returns({'key_state' : 'ready', 'version' : '1'})
+ window.jamClient.InvalidateJamTrack = sinon.stub()
+
+ @downloadJamTrack.init();
+
+ expect(window.jamClient.JamTrackGetTrackDetail.callCount).toBe(1)
+ expect(window.jamClient.InvalidateJamTrack.callCount).toBe(0)
+ expect(@showSynchronizedSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.transitionTimer).toBe(null)
+ expect(@downloadJamTrack.downloadTimer).toBe(null)
+ expect(@statsSpy.calledOnce).toBe(true)
+
+ expect(@downloadJamTrack.stateHolder.find('.state-synchronized')).toHaveLength(1)
+
+ describe "pending", ->
+ beforeEach ->
+ window.jamClient.JamTrackKeysRequest = sinon.stub()
+ @showSynchronizedSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showSynchronized')
+ @showErrorSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showError')
+ @showKeyingSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showKeying')
+ @downloadJamTrack = new JK.DownloadJamTrack(@app, @jamTrack)
+ @downloadJamTrack.states.keying.max_time = -1 # hurry up the test, instead of waiting 10 seconds
+ $('body').append(@downloadJamTrack.root)
+
+ afterEach ->
+ @showSynchronizedSpy.restore()
+ @showErrorSpy.restore()
+ @showKeyingSpy.restore()
+ @downloadJamTrack.destroy()
+
+ it "shows errored state due to timeout", ->
+ window.jamClient.JamTrackGetTrackDetail = sinon.stub()
+ window.jamClient.JamTrackGetTrackDetail.returns({'key_state' : 'pending', 'version' : '1'})
+ window.jamClient.InvalidateJamTrack = sinon.stub()
+
+ @downloadJamTrack.init();
+
+ expect(window.jamClient.JamTrackGetTrackDetail.callCount).toBe(1)
+ expect(@showKeyingSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.states.keying.timer).toNotBe(null)
+
+ @downloadJamTrack.stateIntervalCheck()
+
+ expect(window.jamClient.JamTrackGetTrackDetail.callCount).toBe(2)
+
+ expect(@showErrorSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.states.keying.timer).toBe(null)
+ expect(@downloadJamTrack.stateHolder.find('.state-errored')).toHaveLength(1)
+ expect(@downloadJamTrack.stateHolder.find('.state-errored .msg')).toContainText('It took too long for the JamTrack to be keyed.')
+ expect(@statsSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.attempts).toBe(1)
+
+ # now simulate a retry attempt
+ @downloadJamTrack.stateHolder.find('.retry-button').trigger('click')
+
+ # and verify that we are beginning a re-attempt
+ expect(window.jamClient.JamTrackGetTrackDetail.callCount).toBe(3)
+ expect(@showKeyingSpy.calledTwice).toBe(true)
+ expect(@downloadJamTrack.states.keying.timer).toNotBe(null)
+ expect(@downloadJamTrack.attempts).toBe(2)
+
+
+ it "shows synchronized", ->
+ window.jamClient.JamTrackGetTrackDetail = sinon.stub()
+ window.jamClient.JamTrackGetTrackDetail.returns({'key_state' : 'pending', 'version' : '1'})
+ window.jamClient.InvalidateJamTrack = sinon.stub()
+
+ @downloadJamTrack.init()
+
+ expect(window.jamClient.JamTrackGetTrackDetail.callCount).toBe(1)
+ expect(@showKeyingSpy.calledOnce).toBe(true)
+
+ # keying timer should be firing
+ expect(@downloadJamTrack.states.keying.timer).toNotBe(null)
+
+ # say the keys have been fetched
+ window.jamClient.JamTrackGetTrackDetail.returns({'key_state' : 'ready', 'version' : '1'})
+ window.jamClient.InvalidateJamTrack = sinon.stub()
+
+ # then do a check
+ @downloadJamTrack.stateIntervalCheck()
+
+ expect(@showSynchronizedSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.states.keying.timer).toBe(null)
+ expect(@downloadJamTrack.stateHolder.find('.state-synchronized')).toHaveLength(1)
+ expect(@statsSpy.calledOnce).toBe(true)
+
+
+
+ describe "JamTrack needs downloading", ->
+ beforeEach ->
+ window.jamClient.JamTrackDownload = sinon.stub()
+ @showSynchronizedSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showSynchronized')
+ @showErrorSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showError')
+ @showKeyingSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showKeying')
+ @showDownloadingSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showDownloading')
+ @showPackagingSpy = sinon.spy(JK.DownloadJamTrack.prototype, 'showPackaging')
+ @downloadJamTrack = new JK.DownloadJamTrack(@app, @jamTrack)
+ @downloadJamTrack.states.keying.max_time = -1 # hurry up the test, instead of waiting 10 seconds
+ $('body').append(@downloadJamTrack.root)
+
+ afterEach ->
+ @showSynchronizedSpy.restore()
+ @showErrorSpy.restore()
+ @showKeyingSpy.restore()
+ @showDownloadingSpy.restore()
+ @showPackagingSpy.restore()
+ @downloadJamTrack.destroy()
+
+ it "shows downloading for signed package", ->
+ window.jamClient.JamTrackKeysRequest = sinon.stub()
+ window.jamClient.JamTrackGetTrackDetail = sinon.stub()
+ window.jamClient.JamTrackGetTrackDetail.returns({'key_state' : 'unknown', 'version' : '1'})
+ window.jamClient.InvalidateJamTrack = sinon.stub()
+
+ spyOn(@downloadJamTrack.rest, 'getJamTrackRight').andCallFake((data) =>
+ d = $.Deferred();
+ d.resolve({signing_state: 'SIGNED'});
+ d.promise();
+ )
+
+ window.jamClient.JamTrackDownload = sinon.stub()
+
+ @downloadJamTrack.init()
+
+ expect(window.jamClient.JamTrackGetTrackDetail.callCount).toBe(1)
+ expect(window.jamClient.JamTrackDownload.callCount).toBe(1)
+ expect(@showDownloadingSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.stateHolder.find('.state-downloading')).toHaveLength(1)
+
+ eval(@downloadJamTrack.makeDownloadSuccessCallback() + '()')
+
+ expect(@showKeyingSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.stateHolder.find('.state-keying')).toHaveLength(1)
+
+ # keying timer should be firing
+ expect(@downloadJamTrack.states.keying.timer).toNotBe(null)
+
+ # say the keys have been fetched
+ window.jamClient.JamTrackGetTrackDetail.returns({'key_state' : 'ready', 'version' : '1'})
+ window.jamClient.InvalidateJamTrack = sinon.stub()
+
+ # check state again
+ @downloadJamTrack.stateIntervalCheck()
+
+ # we should now be synchronized
+ expect(@showSynchronizedSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.states.keying.timer).toBe(null)
+ expect(@downloadJamTrack.stateHolder.find('.state-synchronized')).toHaveLength(1)
+ expect(@statsSpy.calledOnce).toBe(true)
+
+ it "is not yet packaged", ->
+ window.jamClient.JamTrackGetTrackDetail = sinon.stub()
+ window.jamClient.JamTrackGetTrackDetail.returns({'key_state' : 'unknown', 'version' : '1'})
+ window.jamClient.InvalidateJamTrack = sinon.stub()
+
+ spyOn(@downloadJamTrack.rest, 'getJamTrackRight').andCallFake((data) =>
+ d = $.Deferred();
+ d.resolve({signing_state: 'QUIET'});
+ d.promise();
+ )
+
+ spyOn(@downloadJamTrack.rest, 'enqueueJamTrack').andCallFake((data) =>
+ d = $.Deferred();
+ d.resolve({});
+ d.promise();
+ )
+
+ window.jamClient.JamTrackDownload = sinon.stub()
+
+ @downloadJamTrack.init()
+
+ expect(@downloadJamTrack.attemptedEnqueue).toBe(true)
+ expect(@downloadJamTrack.transitionTimer?).toBe(true)
+
+ # simulate poke from server saying the track has been queued
+ @downloadJamTrack.onJamTrackRightEvent(null, {body: {signing_state: 'QUEUED'}})
+
+ # the frontend should be saying that it's packaging now
+ expect(@downloadJamTrack.transitionTimer?).toBe(true)
+ expect(@showPackagingSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.stateHolder.find('.state-packaging')).toHaveLength(1)
+
+ # simulate poke from server saying the track is currently signing
+ @downloadJamTrack.onJamTrackRightEvent(null, {body: {signing_state: 'SIGNING'}})
+
+ # the frontend still be saying it's packaging
+ expect(@downloadJamTrack.transitionTimer?).toBe(true)
+ expect(@showPackagingSpy.calledOnce).toBe(true)
+
+ # simulate poke from server saying the track is signed
+ @downloadJamTrack.onJamTrackRightEvent(null, {body: {signing_state: 'SIGNED'}})
+
+ expect(@downloadJamTrack.transitionTimer?).toBe(false)
+
+ # downloading has started; other test covers this, so we stop testing
+ expect(@showDownloadingSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.stateHolder.find('.state-downloading')).toHaveLength(1)
+
+ # since we haven't yet made it to a leave node, make sure we haven't reported a stat
+ expect(@statsSpy.callCount).toBe(0)
+
+ it "queue time out when packaging", ->
+ window.jamClient.JamTrackGetTrackDetail = sinon.stub()
+ window.jamClient.JamTrackGetTrackDetail.returns({'key_state' : 'unknown', 'version' : '1'})
+ window.jamClient.InvalidateJamTrack = sinon.stub()
+
+ getJamTrackRightSpy = spyOn(@downloadJamTrack.rest, 'getJamTrackRight')
+ getJamTrackRightSpy.andCallFake((data) =>
+ d = $.Deferred();
+ d.resolve({signing_state: 'QUIET'});
+ d.promise();
+ )
+
+ spyOn(@downloadJamTrack.rest, 'enqueueJamTrack').andCallFake((data) =>
+ d = $.Deferred();
+ d.resolve({});
+ d.promise();
+ )
+
+ window.jamClient.JamTrackDownload = sinon.stub()
+
+ @downloadJamTrack.init()
+
+ expect(@downloadJamTrack.attemptedEnqueue).toBe(true)
+ expect(@downloadJamTrack.transitionTimer?).toBe(true)
+
+ getJamTrackRightSpy.reset()
+
+ # simulate timer running out, and server check resulting in QUEUED_TIMEOUT
+ getJamTrackRightSpy.andCallFake((data) =>
+ d = $.Deferred();
+ d.resolve({signing_state: 'QUEUED_TIMEOUT'});
+ d.promise();
+ )
+
+ @downloadJamTrack.transitionCheck()
+
+ # the frontend should be saying that it's packaging now
+ expect(@downloadJamTrack.transitionTimer?).toBe(false)
+ expect(@showErrorSpy.calledOnce).toBe(true)
+ expect(@downloadJamTrack.stateHolder.find('.state-errored')).toHaveLength(1)
+ expect(@downloadJamTrack.stateHolder.find('.state-errored .msg')).toContainText('The server took too long to begin processing your JamTrack.')
+
+ expect(@statsSpy.calledOnce).toBe(true)
+
+
+
+
+
+
+
- it "display state correctly", ->
- $track = this.syncViewer.createTrack(this.track1)
- this.syncViewer.updateTrackState($track)