jam-cloud/web/spec/support/utilities.rb

include ApplicationHelper

# holds a single test's session name's, mapped to pooled session names
$capybara_session_mapper = {}

# called in before (or after) test, to make sure each test run has it's own map of session names
def reset_session_mapper
  $capybara_session_mapper.clear
end

# manages the mapped session name
def mapped_session_name(session_name)
  return :default if session_name == :default # special treatment for the built-in session
  $capybara_session_mapper[session_name] ||= $capybara_session_mapper.length
end

# in place of ever using Capybara.session_name directly,
# this utility is used to handle the mapping of session names in a way across all tests runs
def in_client(name)
  session_name = name.class == JamRuby::User ? name.id : name

  Capybara.session_name = mapped_session_name(session_name)

  yield
end


def cookie_jar
  Capybara.current_session.driver.browser.current_session.instance_variable_get(:@rack_mock_session).cookie_jar
end


#see also ruby/spec/support/utilities.rb
JAMKAZAM_TESTING_BUCKET = 'jamkazam-testing' #at least, this is the name given in jam-ruby
def wipe_s3_test_bucket
  s3 = AWS::S3.new(:access_key_id => Rails.application.config.aws_access_key_id,
                   :secret_access_key => Rails.application.config.aws_secret_access_key)
  test_bucket = s3.buckets[JAMKAZAM_TESTING_BUCKET]
  if test_bucket.name == JAMKAZAM_TESTING_BUCKET
    #test_bucket.clear!
  end
end


def sign_in(user)
  visit signin_path
  fill_in "Email",    with: user.email
  fill_in "Password", with: user.password
  click_button "SIGN IN"
  # Sign in when not using Capybara as well.
  cookie_jar[:remember_token] = user.remember_token
end


def sign_in_poltergeist(user)
  visit signin_path
  fill_in "Email",    with: user.email
  fill_in "Password", with: user.password
  click_button "SIGN IN"

  if Capybara.javascript_driver == :poltergeist
    page.driver.set_cookie(:remember_token, user.remember_token)
  else
    page.driver.browser.manage.add_cookie :name => :remember_token, :value => user.remember_token
  end
end

def sign_out()
  if Capybara.javascript_driver == :poltergeist
    page.driver.remove_cookie(:remember_token)
  else
    page.driver.browser.manage.remove_cookie :name => :remember_token
  end
end


def leave_music_session_sleep_delay
  # add a buffer to ensure WSG has enough time to expire
  sleep_dur = (Rails.application.config.websocket_gateway_connect_time_stale +
      Rails.application.config.websocket_gateway_connect_time_expire) * 1.4
  sleep sleep_dur
end


def wait_for_ajax(wait=Capybara.default_wait_time)
  wait = wait * 10 #(because we sleep .1)

  counter = 0
  while page.execute_script("$.active").to_i > 0
    counter += 1
    sleep(0.1)
    raise "AJAX request took longer than #{wait} seconds." if counter >= wait
  end
end

# waits until the user object has been requested, which comes after the 'curtain' is lifted
# and after a call to /api/user/:id for the current user is called initially
def wait_until_user(wait=Capybara.default_wait_time)
  wait = wait * 10 #(because we sleep .1)

  counter = 0
  # while page.execute_script("$('.curtain').is(:visible)") == "true"
  #   counter += 1
  #   sleep(0.1)
  #   raise "Waiting for user to populate took longer than #{wait} seconds." if counter >= wait
  # end
end

def wait_until_curtain_gone
  should have_no_selector('.curtain')
end

def wait_to_see_my_track
  within('div.session-mytracks') {first('div.session-track.track')}
end

def determine_test_name(metadata, test_name_buffer = '')
  description = metadata[:description_args]
  if description.kind_of?(Array)
    description = description[0]
  end
  if metadata.has_key? :example_group
    return determine_test_name(metadata[:example_group], "#{description} #{test_name_buffer}")
  else
    return "#{description} #{test_name_buffer}"
  end
end

def get_description
  description = example.metadata[:description_args]
  if description.kind_of?(Array)
    description = description[0]
  end
  return description
end


# takes, or creates, a unique session description which is returned for subsequent calls to join_session to use
# in finding this session)
def create_session(creator = FactoryGirl.create(:user), unique_session_desc = nil, genre = nil)
  unique_session_desc ||= "create_join_session #{SecureRandom.urlsafe_base64}"
  genre ||= 'Rock'

  # create session in one client
  in_client(creator) do
    page.driver.resize(1500, 800) # makes sure all the elements are visible
    sign_in_poltergeist creator
    wait_until_curtain_gone
    visit "/client#/createSession"
    expect(page).to have_selector('h2',    text: 'session info')

    within('#create-session-form') do
      fill_in('description', :with => unique_session_desc)
      select(genre, :from => 'genres')
      find('div.intellectual-property ins').trigger(:click)
      find('#btn-create-session').trigger(:click)     # fails if page width is low
    end

    # verify that the in-session page is showing
    expect(page).to have_selector('h2',    text: 'my tracks')
  end

  return creator, unique_session_desc, genre

end


# this code assumes that there are no music sessions in the database. it should fail on the
# find('.join-link') call if > 1 session exists because capybara will complain of multiple matches
def join_session(joiner, unique_session_desc)

  in_client(joiner) do
    sign_in_poltergeist joiner
    wait_until_curtain_gone
    visit "/client#/findSession"

    # verify the session description is seen by second client
    expect(page).to have_text(unique_session_desc)
    find('.join-link').trigger(:click)
    find('#btn-accept-terms').trigger(:click)
    expect(page).to have_selector('h2',    text: 'my tracks')
  end
end


def create_join_session(creator, joiners=[], genre=nil)
  creator, unique_session_desc = create_session(creator, nil, genre)

  # find session in second client
  joiners.each do |joiner|
    join_session(joiner, unique_session_desc)
  end
end

def start_recording_with(creator, joiners=[], genre=nil)
  create_join_session(creator, joiners, genre)
  in_client(creator) do
    find('#recording-start-stop').trigger(:click)
    find('#recording-status').should have_content 'Stop Recording'
  end
  joiners.each do |joiner|
    in_client(joiner) do
      find('#notification').should have_content 'started a recording'
      find('#recording-status').should have_content 'Stop Recording'
    end
  end
end

def stop_recording
  find('#recording-start-stop').trigger(:click)
end

def assert_recording_finished
  find('#recording-status').should have_content 'Make a Recording'
  should have_selector('h1', text: 'recording finished')
end

def check_recording_finished_for(users=[])
  users.each do |user|
    in_client(user) do
      assert_recording_finished
    end
  end
end

def claim_recording(name, description)
  find('#recording-finished-dialog h1')
  fill_in "claim-recording-name",    with: name
  fill_in "claim-recording-description",    with: description
  find('#keep-session-recording').trigger(:click)
  should have_no_selector('h1',  text: 'recording finished')
end

def set_session_as_private()
  find('#session-settings-button').trigger(:click)
  within('#session-settings-dialog') do
      select('Private', :from => 'session-settings-musician-access')
      find('#session-settings-dialog-submit').trigger(:click)
  end
end

def set_session_as_public()
  find('#session-settings-button').trigger(:click)
  within('#session-settings-dialog') do
    select('Public', :from => 'session-settings-musician-access')
    find('#session-settings-dialog-submit').trigger(:click)
  end
end

def get_options(selector)
  return find(selector).all('option').collect(&:text).uniq
end

def selected_genres(selector='#session-settings-genre')
  return page.evaluate_script("JK.GenreSelectorHelper.getSelectedGenres('#{selector}')")
end

def random_genre
  ['African',
   'Ambient',
   'Asian',
   'Blues',
   'Classical',
   'Country',
   'Electronic',
   'Folk',
   'Hip Hop',
   'Jazz',
   'Latin',
   'Metal',
   'Pop',
   'R&B',
   'Reggae',
   'Religious',
   'Rock',
   'Ska',
   'Other'].sample
end

def change_session_genre   #randomly just change it
  here = 'select.genre-list'
  #wait_for_ajax
  find('#session-settings-button').trigger(:click)
      within('#session-settings-dialog') do
        wait_for_ajax
        @new_genre = get_options(here).-(["Select Genre"]).-(selected_genres).sample.to_s
        select(@new_genre, :from => 'genres')
        wait_for_ajax
        find('#session-settings-dialog-submit').trigger(:click)
      end
  return @new_genre
end

def get_session_genre
  here = 'select.genre-list'
  find('#session-settings-button').trigger(:click)
  wait_for_ajax
  @current_genres = selected_genres
  find('#session-settings-dialog-submit').trigger(:click)
  return @current_genres.join(" ")
end

def find_session_contains?(text)
    visit "/client#/findSession"
    wait_for_ajax
    within('#find-session-form') do
      expect(page).to have_text(text)
    end
end

def assert_all_tracks_seen(users=[])
  users.each do |user|
    in_client(user) do
      users.reject {|u| u==user}.each do |other|
        expect(page).to have_selector('div.track-label',  text: other.name)
        #puts user.name + " is able to see " + other.name + "\'s track"
      end
    end
  end
end

def show_user_menu
  page.execute_script("$('ul.shortcuts').show()")
  #page.execute_script("JK.UserDropdown.menuHoverIn()")
end