jam-cloud/ruby/spec/jam_ruby/models/musician_search_spec.rb

require 'spec_helper'

describe User do

  before(:each) do
    @geocode1 = FactoryGirl.create(:geocoder)
    @geocode2 = FactoryGirl.create(:geocoder)
    params = {
      first_name: "Example", 
      last_name: "User", 
      email: "user1@example.com",
      password: "foobar", 
      password_confirmation: "foobar", 
      musician: true, 
      email_confirmed: true,
      city: "Apex", 
      state: "NC", 
      country: "US"
    }
    @users = []
    @users << @user1 = FactoryGirl.create(:user, params)
    params[:email] = "user2@example.com"
    @users << @user2 = FactoryGirl.create(:user, params)
    params[:email] = "user3@example.com"
    @users << @user3 = FactoryGirl.create(:user, params)
    params[:email] = "user4@example.com"
    @users << @user4 = FactoryGirl.create(:user, params)
  end

  it "should find all musicians sorted by followers with pagination" do
    # establish sorting order
    @user4.followers.concat([@user2, @user3, @user4])
    @user3.followers.concat([@user3, @user4])
    @user2.followers.concat([@user1])
    @user4.followers.count.should == 3

    UserFollower.count.should == 6

    # get all the users in correct order
    params = { :per_page => @users.size }
    results = Search.musician_search(params)
    results.musicians.count.should == @users.size

    results.musicians.each_with_index do |uu, idx|
      uu.id.should == @users.reverse[idx].id
    end

    # refresh the order to ensure it works right
    @user2.followers.concat([@user3, @user4, @user2])
    results = Search.musician_search(params, @user3)
    results.musicians[0].id.should == @user2.id

    # check the follower count for given entry
    results.musicians[0].search_follow_count.to_i.should_not == 0
    # check the follow relationship between current_user and result
    results.is_follower?(@user2).should == true

    # make sure pagination works right
    params = { :per_page => 2, :page => 1 }
    results = Search.musician_search(params)
    results.musicians.count.should == 2
  end

  it "should have friends counter " do
    Friendship.save(@user1.id, @user2.id)
    results = Search.musician_search({}, @user2)
    friend = results.musicians.detect { |mm| mm.id == @user1.id }
    friend.should_not == nil
    results.friend_count(friend).should == 1
    @user1.reload
    friend.friends?(@user2).should == true
    results.is_friend?(@user1).should == true
  end

  def make_recording(uu)
    connection = FactoryGirl.create(:connection, :user => uu)
    instrument = FactoryGirl.create(:instrument, :description => 'a great instrument')
    track = FactoryGirl.create(:track, :connection => connection, :instrument => instrument)
    music_session = FactoryGirl.create(:music_session, :creator => uu, :musician_access => true)
    music_session.connections << connection
    music_session.save
    recording = Recording.start(music_session, uu)
    recording.stop
    recording.reload
    genre = FactoryGirl.create(:genre)
    recording.claim(uu, "name", "description", genre, true, true)
    recording.reload
    recording
  end

  it "should have recording counter " do
    recording = make_recording(@user1)
    recording.users.length.should == 1
    recording.users.first.should == @user1
    @user1.reload
    @user1.recordings.length.should == 1
    @user1.recordings.first.should == recording
    recording.claimed_recordings.length.should == 1
    @user1.recordings.detect { |rr| rr == recording }.should_not be nil

    results = Search.musician_search({},@user1)
    uu = results.musicians.detect { |mm| mm.id == @user1.id }
    uu.should_not == nil

    results.record_count(uu).should == 1
    results.session_count(uu).should == 1
  end

  it "should find musicians sorted by plays" do
    make_recording(@user1)
    results = Search.musician_search({ :orderby => 'plays' }, @user2)
    results.musicians[0].id.should == @user1.id
    make_recording(@user2)
    make_recording(@user2)
    results = Search.musician_search({ :orderby => 'plays' }, @user2)
    results.musicians[0].id.should == @user2.id
  end

  it "should find all musicians sorted by now playing" do
    connection = FactoryGirl.create(:connection, :user => @user3)
    music_session = FactoryGirl.create(:music_session, :creator => @user3, :musician_access => true)
    music_session.connections << connection
    music_session.save
    results = Search.musician_search({ :orderby => 'playing' }, @user2)
    results.musicians.count.should == 1
    connection = FactoryGirl.create(:connection, :user => @user4)
    music_session = FactoryGirl.create(:music_session, :creator => @user4, :musician_access => true)
    music_session.connections << connection
    music_session.save
    results = Search.musician_search({ :orderby => 'playing' }, @user2)
    results.musicians.count.should == 2
    connection = FactoryGirl.create(:connection, :user => @user1)
    music_session = FactoryGirl.create(:music_session, :creator => @user1, :musician_access => true)
    music_session.connections << connection
    music_session.save
    results = Search.musician_search({ :orderby => 'playing' }, @user2)
    results.musicians.count.should == 3
  end

  it "should find musicians with an instrument" do
    minst = FactoryGirl.create(:musician_instrument, { 
                                 :user => @user1,
                                 :instrument => Instrument.find('tuba') })
    @user1.musician_instruments << minst
    @user1.reload
    ii = @user1.instruments.detect { |inst| inst.id == 'tuba' }
    ii.should_not be_nil
    params = { :instrument => ii.id }
    results = Search.musician_search(params)
    results.musicians.each do |rr|
      rr.instruments.detect { |inst| inst.id=='tuba' }.id.should == ii.id
    end
    results.musicians.count.should == 1
  end

  it "should find musicians within a given distance of location" do
    @user1.lat.should_not == nil
    params = { :distance => 10, :city => 'San Francisco' }
    results = Search.musician_search(params)
    results.musicians.count.should == 0

    params = { :distance => 10, :city => 'Apex' }
    results = Search.musician_search(params)
    results.musicians.count.should == User.count

    params = { :distance => 10 }
    results = Search.musician_search(params)
    results.musicians.count.should == User.count
  end

end