vrfs-774: refactored api tests; added geocoding support

web/spec/factories.rb

@@ -128,5 +128,14 @@ FactoryGirl.define do
   end
 
   
-  
+  factory :geocoder, :class => JamRuby::MaxMindGeo do
+    country 'US'
+    sequence(:region) { |n| ['NC', 'CA'][(n-1).modulo(2)] }
+    sequence(:city) { |n| ['Apex', 'San Francisco'][(n-1).modulo(2)] }
+    sequence(:ip_start) { |n| ['1.1.0.0', '1.1.255.255'][(n-1).modulo(2)] }
+    sequence(:ip_end) { |n| ['1.2.0.0', '1.2.255.255'][(n-1).modulo(2)] }
+    sequence(:lat) { |n| [35.73265, 37.7742075][(n-1).modulo(2)] }
+    sequence(:lng) { |n| [-78.85029, -122.4155311][(n-1).modulo(2)] }
+  end
+
 end

web/spec/requests/musician_search_api_spec.rb

@@ -6,89 +6,86 @@ describe "Musician Search API", :type => :api do
 
   def get_query(query={})
     qstr = ''
-    query.each { |kk,vv| qstr += "#{kk}=#{vv}&" }
-    get "/api/search.json?#{Search::PARAM_MUSICIAN}=1&#{qstr}"
+    query.each { |kk,vv| qstr += "#{kk}=#{CGI::escape(vv.to_s)}&" }
+    uri = "/api/search.json?#{Search::PARAM_MUSICIAN}=1&#{qstr}"
+    get uri, "CONTENT_TYPE" => 'application/json'
   end
 
-
-  describe "profile page" do
+  describe "musician search page" do
     let(:user) { FactoryGirl.create(:user) }
 
     before(:each) do
-      post '/sessions', "session[email]" => user.email, "session[password]" => user.password
-      rack_mock_session.cookie_jar["remember_token"].should == user.remember_token
-    end
-
-    it "blank search" do
-      get_query
-      last_response.status.should == 200
-      sobj = JSON.parse(last_response.body)
-      sobj.count.should >= 1
-      sobj['musicians'].count.should == [Search::M_PER_PAGE, 
-                                         User.where(:musician => true).count].min
-    end
-
-    it "instrument search" do
-      minst = FactoryGirl.create(:musician_instrument, { 
-                                   :user => user,
-                                   :instrument => Instrument.find('tuba') })
-      user.musician_instruments << minst
-
-      get_query({:instrument => 'tuba'})
-      last_response.status.should == 200
-      response = JSON.parse(last_response.body)
-      
-      response["musicians"].length.should == 1
-      musician = response["musicians"][0]
-      musician["id"].should == user.id
-      instruments = musician['instruments']
-      instruments.detect { |ii| ii['instrument_id'] == 'tuba' }.should_not == nil
-      instruments.detect { |ii| ii['instrument_id'] == 'electric guitar' }.should_not == nil
-    end
-
-    it "following search" do
-      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"
-      }
+      2.downto(1) { FactoryGirl.create(:geocoder) }
       @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)
-      @user4.followers.concat([@user2, @user3, @user4])
-      @user3.followers.concat([@user3, @user4])
-      @user2.followers.concat([@user4])
-      @user4.followers.count.should == 3
+      @users << @user1 = FactoryGirl.create(:user)
+      @users << @user2 = FactoryGirl.create(:user)
+      @users << @user3 = FactoryGirl.create(:user)
+      @users << @user4 = FactoryGirl.create(:user)
 
-      Friendship.save(@user1.id, @user2.id)
+      post '/sessions', "session[email]" => user.email, "session[password]" => user.password
+      expect(rack_mock_session.cookie_jar["remember_token"]).to eq(user.remember_token)
+    end
 
+    it "default search" do
       get_query
-      last_response.status.should == 200
-      response = JSON.parse(last_response.body)
-      
-      musician = response["musicians"][0]
-      musician["id"].should == @user4.id
-      followings= musician['followings']
-      followings.length.should == 3
-      musician['follow_count'].to_i.should > 0
+      good_response
+      expect(json['musicians'].count).to be [Search::M_PER_PAGE, User.musicians_geocoded.count].min
+    end
 
-      friend = response['musicians'].detect { |mm| mm['id'] == @user1.id }
-      friend['friend_count'].should == 1
+    context 'location filtering' do
 
-      musician['recording_count'].should == 0
-      musician['session_count'].should == 0
+      it "gets no musicians for out of range locations" do
+        get_query({:city => 'San Francisco', :distance => 100})
+        good_response
+        expect((json['musicians'] || []).count).to be 0
+      end
+
+      it "gets musicians for long-distance locations" do
+        get_query({:city => 'Miami', :distance => 1000})
+        good_response
+        expect(json['musicians'].count).to be >= 1
+      end
+
+    end
+
+    context 'instrument filtering' do 
+
+      it "gets musicians for default instrument" do
+        get_query({:instrument => 'electric guitar'})
+        good_response
+        expect(json.count).to be >= 1
+      end
+
+      it "gets no musicians for unused instruments" do
+        get_query({:instrument => 'tuba'})
+        good_response
+        expect(json.count).to be 0
+      end
+
+    end
+
+    context 'results have expected data' do
+      it "has follower stats " do
+        @user4.followers.concat([@user2, @user3, @user4])
+        @user3.followers.concat([@user3, @user4])
+        @user2.followers.concat([@user4])
+        expect(@user4.followers.count).to be 3
+        get_query
+        good_response
+        musician = json["musicians"][0]
+        expect(musician["id"]).to eq(@user4.id)
+        followings = musician['followings']
+        expect(followings.length).to be 3
+        expect(musician['follow_count'].to_i).to be > 0
+      end
+
+      it "has friend stats" do
+        Friendship.save(@user1.id, @user2.id)
+        get_query
+        good_response
+        friend = json['musicians'].detect { |mm| mm['id'] == @user1.id }
+        expect(friend['friend_count']).to be 1
+      end
     end
   end
 end

web/spec/spec_helper.rb

@@ -93,6 +93,8 @@ Spork.prefork do
     # rspec-rails.
     config.infer_base_class_for_anonymous_controllers = false
 
+    config.include Requests::JsonHelpers, type: :request
+
     config.before(:suite) do
     end
 

web/spec/support/request_helpers.rb

@@ -0,0 +1,13 @@
+module Requests
+  module JsonHelpers
+
+    def json
+      @json ||= JSON.parse(last_response.body)
+    end
+
+    def good_response
+      expect(last_response.status).to be 200
+    end
+
+  end
+end