openstax_accounts 3.1.1 → 4.0.0

data/spec/dummy/config/initializers/openstax_accounts.rb

@@ -9,5 +9,6 @@ OpenStax::Accounts.configure do |config|
   config.openstax_application_secret = 'secret'
   config.account_user_mapper = User
   config.logout_via = :delete
-  config.max_matching_accounts = 47
+  config.min_search_characters = 3
+  config.max_search_items = 10
 end

data/spec/dummy/db/schema.rb

@@ -11,7 +11,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20140811182553) do
+ActiveRecord::Schema.define(version: 6) do
 
   create_table "openstax_accounts_accounts", force: true do |t|
     t.integer  "openstax_uid", null: false

data/spec/factories/openstax_accounts_account.rb

@@ -1,6 +1,6 @@
 FactoryGirl.define do
   factory :openstax_accounts_account, :class => OpenStax::Accounts::Account do
-    openstax_uid { -SecureRandom.hex.to_i(16) }
+    openstax_uid { -SecureRandom.hex(4).to_i(16)/2 }
     username     { SecureRandom.hex.to_s }
     access_token { SecureRandom.hex.to_s }
   end

data/spec/factories/openstax_accounts_group.rb

@@ -1,6 +1,6 @@
 FactoryGirl.define do
   factory :openstax_accounts_group, :class => OpenStax::Accounts::Group do
-    openstax_uid { -SecureRandom.hex.to_i(16) }
+    openstax_uid { -SecureRandom.hex(4).to_i(16)/2 }
     name "MyGroup"
     is_public false
   end

data/spec/handlers/openstax/accounts/accounts_search_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module OpenStax
+  module Accounts
+
+    describe AccountsSearch do
+      
+      let!(:account_1)          { FactoryGirl.create :openstax_accounts_account,
+                                                  first_name: 'John',
+                                                  last_name: 'Stravinsky',
+                                                  username: 'jstrav' }
+      let!(:account_2)          { FactoryGirl.create :openstax_accounts_account,
+                                                  first_name: 'Mary',
+                                                  last_name: 'Mighty',
+                                                  full_name: 'Mary Mighty',
+                                                  username: 'mary' }
+      let!(:account_3)          { FactoryGirl.create :openstax_accounts_account,
+                                                  first_name: 'John',
+                                                  last_name: 'Stead',
+                                                  username: 'jstead' }
+
+      let!(:account_4)          { FactoryGirl.create :openstax_accounts_account,
+                                                  first_name: 'Bob',
+                                                  last_name: 'JST',
+                                                  username: 'bigbear' }
+
+      let!(:billy_accounts) {
+        (0..49).to_a.collect{|ii|
+          FactoryGirl.create :openstax_accounts_account,
+                             first_name: "Billy#{ii.to_s.rjust(2, '0')}",
+                             last_name: "Bob_#{(49-ii).to_s.rjust(2,'0')}",
+                             username: "billy_#{ii.to_s.rjust(2, '0')}"
+        }
+      }
+
+      it "should match based on username" do
+        outputs = AccountsSearch.call(params: {search: {query: "username:jstra"}}).outputs
+        expect(outputs.total_count).to eq 1
+        expect(outputs.items).to eq [account_1]
+      end
+
+      it "should return no results if the query is too short" do
+        routine = AccountsSearch.call(params: {search: {query: ""}})
+        outputs = routine.outputs
+        errors = routine.errors
+        expect(outputs.total_count).to be_nil
+        expect(outputs.items).to be_nil
+        expect(errors.last.code).to eq :query_too_short
+      end
+
+      it "should return no results if the limit is exceeded" do
+        routine = AccountsSearch.call(params: {search: {query: "billy"}})
+        outputs = routine.outputs
+        errors = routine.errors
+        expect(outputs.total_count).to eq 50
+        expect(outputs.items).to be_nil
+        expect(errors.last.code).to eq :too_many_items
+      end
+
+    end
+
+  end
+end

data/spec/handlers/openstax/accounts/dev/accounts_search_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module OpenStax
+  module Accounts
+
+    describe Dev::AccountsSearch do
+      
+      let!(:account_1)          { FactoryGirl.create :openstax_accounts_account,
+                                                  first_name: 'John',
+                                                  last_name: 'Stravinsky',
+                                                  username: 'jstrav' }
+      let!(:account_2)          { FactoryGirl.create :openstax_accounts_account,
+                                                  first_name: 'Mary',
+                                                  last_name: 'Mighty',
+                                                  full_name: 'Mary Mighty',
+                                                  username: 'mary' }
+      let!(:account_3)          { FactoryGirl.create :openstax_accounts_account,
+                                                  first_name: 'John',
+                                                  last_name: 'Stead',
+                                                  username: 'jstead' }
+
+      let!(:account_4)          { FactoryGirl.create :openstax_accounts_account,
+                                                  first_name: 'Bob',
+                                                  last_name: 'JST',
+                                                  username: 'bigbear' }
+
+      let!(:billy_accounts) {
+        (0..49).to_a.collect{|ii|
+          FactoryGirl.create :openstax_accounts_account,
+                             first_name: "Billy#{ii.to_s.rjust(2, '0')}",
+                             last_name: "Bob_#{(49-ii).to_s.rjust(2,'0')}",
+                             username: "billy_#{ii.to_s.rjust(2, '0')}"
+        }
+      }
+
+      it "should match based on username" do
+        outputs = Dev::AccountsSearch.call(params: {search: {query: "username:jstra"}}).outputs
+        expect(outputs.total_count).to eq 1
+        expect(outputs.items).to eq [account_1]
+      end
+
+      it "should have no limits" do
+        routine = Dev::AccountsSearch.call(params: {search: {query: ""}})
+        outputs = routine.outputs
+        errors = routine.errors
+        expect(outputs.total_count).to eq 54
+        expect(outputs.items).to eq [account_4, billy_accounts, account_3,
+                                     account_1, account_2].flatten
+        expect(errors).to be_empty
+      end
+
+    end
+
+  end
+end

data/spec/lib/openstax_accounts_spec.rb

@@ -6,11 +6,11 @@ module OpenStax
                        title: 'Sir', openstax_uid: 1, access_token: 'secret') }
 
     it 'makes api calls' do
-      expect(Api::DummyController.last_action).to be_nil
-      expect(Api::DummyController.last_params).to be_nil
+      expect(::Api::DummyController.last_action).to be_nil
+      expect(::Api::DummyController.last_params).to be_nil
       Accounts.api_call(:post, 'dummy', :params => {:test => true})
-      expect(Api::DummyController.last_action).to eq :dummy
-      expect(Api::DummyController.last_params).to include 'test' => 'true'
+      expect(::Api::DummyController.last_action).to eq :dummy
+      expect(::Api::DummyController.last_params).to include 'test' => 'true'
     end
 
     context 'users' do
@@ -18,19 +18,19 @@ module OpenStax
       let!(:account) { FactoryGirl.create :openstax_accounts_account }
 
       it 'makes api call to users index' do
-        Api::UsersController.last_action = nil
-        Api::UsersController.last_params = nil
+        ::Api::UsersController.last_action = nil
+        ::Api::UsersController.last_params = nil
         Accounts.search_accounts('something')
-        expect(Api::UsersController.last_action).to eq :index
-        expect(Api::UsersController.last_params).to include :q => 'something'
+        expect(::Api::UsersController.last_action).to eq :index
+        expect(::Api::UsersController.last_params).to include :q => 'something'
       end
 
       it 'makes api call to user update' do
-        Api::UsersController.last_action = nil
-        Api::UsersController.last_json = nil
+        ::Api::UsersController.last_action = nil
+        ::Api::UsersController.last_json = nil
         Accounts.update_account(account)
-        expect(Api::UsersController.last_action).to eq :update
-        expect(Api::UsersController.last_json).to include(
+        expect(::Api::UsersController.last_action).to eq :update
+        expect(::Api::UsersController.last_json).to include(
           account.attributes.slice('username', 'first_name',
             'last_name', 'full_name', 'title'))
       end
@@ -40,25 +40,25 @@ module OpenStax
     context 'application_users' do
 
       it 'makes api call to application_users index' do
-        Api::ApplicationUsersController.last_action = nil
-        Api::ApplicationUsersController.last_params = nil
+        ::Api::ApplicationUsersController.last_action = nil
+        ::Api::ApplicationUsersController.last_params = nil
         Accounts.search_application_accounts('something')
-        expect(Api::ApplicationUsersController.last_action).to eq :index
-        expect(Api::ApplicationUsersController.last_params).to include :q => 'something'
+        expect(::Api::ApplicationUsersController.last_action).to eq :index
+        expect(::Api::ApplicationUsersController.last_params).to include :q => 'something'
       end
 
       it 'makes api call to application_users updates' do
-        Api::ApplicationUsersController.last_action = nil
+        ::Api::ApplicationUsersController.last_action = nil
         Accounts.get_application_account_updates
-        expect(Api::ApplicationUsersController.last_action).to eq :updates
+        expect(::Api::ApplicationUsersController.last_action).to eq :updates
       end
 
       it 'makes api call to application_users updated' do
-        Api::ApplicationUsersController.last_action = nil
-        Api::ApplicationUsersController.last_json = nil
+        ::Api::ApplicationUsersController.last_action = nil
+        ::Api::ApplicationUsersController.last_json = nil
         Accounts.mark_account_updates_as_read([{id: 1, read_updates: 1}])
-        expect(Api::ApplicationUsersController.last_action).to eq :updated
-        expect(Api::ApplicationUsersController.last_json).to include(
+        expect(::Api::ApplicationUsersController.last_action).to eq :updated
+        expect(::Api::ApplicationUsersController.last_json).to include(
           {'id' => 1, 'read_updates' => 1})
       end
 
@@ -70,34 +70,34 @@ module OpenStax
       let!(:group)   { FactoryGirl.create :openstax_accounts_group }
 
       it 'makes api call to groups create' do
-        Api::GroupsController.last_action = nil
-        Api::GroupsController.last_json = nil
+        ::Api::GroupsController.last_action = nil
+        ::Api::GroupsController.last_json = nil
         Accounts.create_group(account, group)
-        expect(Api::GroupsController.last_action).to eq :create
-        expect(Api::GroupsController.last_json).to include(
+        expect(::Api::GroupsController.last_action).to eq :create
+        expect(::Api::GroupsController.last_json).to include(
           {'name' => 'MyGroup', 'is_public' => false})
       end
 
       it 'makes api call to group update' do
         group.save!
-        Api::GroupsController.last_action = nil
-        Api::GroupsController.last_params = nil
-        Api::GroupsController.last_json = nil
+        ::Api::GroupsController.last_action = nil
+        ::Api::GroupsController.last_params = nil
+        ::Api::GroupsController.last_json = nil
         Accounts.update_group(account, group)
-        expect(Api::GroupsController.last_action).to eq :update
-        expect(Api::GroupsController.last_params).to include(
+        expect(::Api::GroupsController.last_action).to eq :update
+        expect(::Api::GroupsController.last_params).to include(
           {'id' => group.openstax_uid.to_s})
-        expect(Api::GroupsController.last_json).to include(
+        expect(::Api::GroupsController.last_json).to include(
           {'name' => group.name, 'is_public' => group.is_public})
       end
 
       it 'makes api call to group destroy' do
         group.save!
-        Api::GroupsController.last_action = nil
-        Api::GroupsController.last_params = nil
+        ::Api::GroupsController.last_action = nil
+        ::Api::GroupsController.last_params = nil
         Accounts.destroy_group(account, group)
-        expect(Api::GroupsController.last_action).to eq :destroy
-        expect(Api::GroupsController.last_params).to include(
+        expect(::Api::GroupsController.last_action).to eq :destroy
+        expect(::Api::GroupsController.last_params).to include(
           {'id' => group.openstax_uid.to_s})
       end
 
@@ -109,22 +109,22 @@ module OpenStax
       let!(:group_member)   { FactoryGirl.build :openstax_accounts_group_member }
 
       it 'makes api call to group_members create' do
-        Api::GroupMembersController.last_action = nil
-        Api::GroupMembersController.last_params = nil
+        ::Api::GroupMembersController.last_action = nil
+        ::Api::GroupMembersController.last_params = nil
         Accounts.create_group_member(account, group_member)
-        expect(Api::GroupMembersController.last_action).to eq :create
-        expect(Api::GroupMembersController.last_params).to include(
+        expect(::Api::GroupMembersController.last_action).to eq :create
+        expect(::Api::GroupMembersController.last_params).to include(
           {'group_id' => group_member.group_id.to_s,
            'user_id' => group_member.user_id.to_s})
       end
 
       it 'makes api call to group_member destroy' do
         group_member.save!
-        Api::GroupMembersController.last_action = nil
-        Api::GroupMembersController.last_params = nil
+        ::Api::GroupMembersController.last_action = nil
+        ::Api::GroupMembersController.last_params = nil
         Accounts.destroy_group_member(account, group_member)
-        expect(Api::GroupMembersController.last_action).to eq :destroy
-        expect(Api::GroupMembersController.last_params).to include(
+        expect(::Api::GroupMembersController.last_action).to eq :destroy
+        expect(::Api::GroupMembersController.last_params).to include(
           {'group_id' => group_member.group_id.to_s,
            'user_id' => group_member.user_id.to_s})
       end
@@ -137,22 +137,22 @@ module OpenStax
       let!(:group_owner) { FactoryGirl.build :openstax_accounts_group_owner }
 
       it 'makes api call to group_owners create' do
-        Api::GroupOwnersController.last_action = nil
-        Api::GroupOwnersController.last_params = nil
+        ::Api::GroupOwnersController.last_action = nil
+        ::Api::GroupOwnersController.last_params = nil
         Accounts.create_group_owner(account, group_owner)
-        expect(Api::GroupOwnersController.last_action).to eq :create
-        expect(Api::GroupOwnersController.last_params).to include(
+        expect(::Api::GroupOwnersController.last_action).to eq :create
+        expect(::Api::GroupOwnersController.last_params).to include(
           {'group_id' => group_owner.group_id.to_s,
            'user_id' => group_owner.user_id.to_s})
       end
 
       it 'makes api call to group_owner destroy' do
         group_owner.save!
-        Api::GroupOwnersController.last_action = nil
-        Api::GroupOwnersController.last_params = nil
+        ::Api::GroupOwnersController.last_action = nil
+        ::Api::GroupOwnersController.last_params = nil
         Accounts.destroy_group_owner(account, group_owner)
-        expect(Api::GroupOwnersController.last_action).to eq :destroy
-        expect(Api::GroupOwnersController.last_params).to include(
+        expect(::Api::GroupOwnersController.last_action).to eq :destroy
+        expect(::Api::GroupOwnersController.last_params).to include(
           {'group_id' => group_owner.group_id.to_s,
            'user_id' => group_owner.user_id.to_s})
       end
@@ -165,22 +165,22 @@ module OpenStax
       let!(:group_nesting) { FactoryGirl.build :openstax_accounts_group_nesting }
 
       it 'makes api call to group_nestings (create)' do
-        Api::GroupNestingsController.last_action = nil
-        Api::GroupNestingsController.last_params = nil
+        ::Api::GroupNestingsController.last_action = nil
+        ::Api::GroupNestingsController.last_params = nil
         Accounts.create_group_nesting(account, group_nesting)
-        expect(Api::GroupNestingsController.last_action).to eq :create
-        expect(Api::GroupNestingsController.last_params).to include(
+        expect(::Api::GroupNestingsController.last_action).to eq :create
+        expect(::Api::GroupNestingsController.last_params).to include(
           {'group_id' => group_nesting.container_group_id.to_s,
            'member_group_id' => group_nesting.member_group_id.to_s})
       end
 
       it 'makes api call to group_nesting (destroy)' do
         group_nesting.save!
-        Api::GroupNestingsController.last_action = nil
-        Api::GroupNestingsController.last_params = nil
+        ::Api::GroupNestingsController.last_action = nil
+        ::Api::GroupNestingsController.last_params = nil
         Accounts.destroy_group_nesting(account, group_nesting)
-        expect(Api::GroupNestingsController.last_action).to eq :destroy
-        expect(Api::GroupNestingsController.last_params).to include(
+        expect(::Api::GroupNestingsController.last_action).to eq :destroy
+        expect(::Api::GroupNestingsController.last_params).to include(
           {'group_id' => group_nesting.container_group_id.to_s,
            'member_group_id' => group_nesting.member_group_id.to_s})
       end
@@ -190,17 +190,17 @@ module OpenStax
     context 'application_groups' do
 
       it 'makes api call to application_groups_updates' do
-        Api::ApplicationGroupsController.last_action = nil
+        ::Api::ApplicationGroupsController.last_action = nil
         Accounts.get_application_group_updates
-        expect(Api::ApplicationGroupsController.last_action).to eq :updates
+        expect(::Api::ApplicationGroupsController.last_action).to eq :updates
       end
 
       it 'makes api call to application_groups_updated' do
-        Api::ApplicationGroupsController.last_action = nil
-        Api::ApplicationGroupsController.last_json = nil
+        ::Api::ApplicationGroupsController.last_action = nil
+        ::Api::ApplicationGroupsController.last_json = nil
         Accounts.mark_group_updates_as_read([{id: 1, read_updates: 1}])
-        expect(Api::ApplicationGroupsController.last_action).to eq :updated
-        expect(Api::ApplicationGroupsController.last_json).to include(
+        expect(::Api::ApplicationGroupsController.last_action).to eq :updated
+        expect(::Api::ApplicationGroupsController.last_json).to include(
           {'id' => 1, 'read_updates' => 1})
       end
 

data/spec/routines/openstax/accounts/search_accounts_spec.rb

@@ -25,50 +25,55 @@ module OpenStax
                                                   username: 'bigbear' }
 
       it "should match based on username" do
-        outcome = SearchAccounts.call('username:jstra').outputs.accounts.all
+        outcome = SearchAccounts.call('username:jstra').outputs.items
         expect(outcome).to eq [account_1]
       end
 
       it "should ignore leading wildcards on username searches" do
-        outcome = SearchAccounts.call('username:%rav').outputs.accounts.all
+        outcome = SearchAccounts.call('username:%rav').outputs.items
         expect(outcome).to eq []
       end
 
       it "should match based on one first name" do
-        outcome = SearchAccounts.call('first_name:"John"').outputs.accounts.all
+        outcome = SearchAccounts.call('first_name:"John"').outputs.items
         expect(outcome).to eq [account_3, account_1]
       end
 
       it "should match based on one full name" do
-        outcome = SearchAccounts.call('full_name:"Mary Mighty"').outputs.accounts.all
+        outcome = SearchAccounts.call('full_name:"Mary Mighty"').outputs.items
         expect(outcome).to eq [account_2]
       end
 
       it "should return all results if the query is empty" do
-        outcome = SearchAccounts.call("").outputs.accounts.all
+        outcome = SearchAccounts.call("").outputs.items
         expect(outcome).to eq [account_4, account_3, account_1, account_2]
       end
 
       it "should match any field when no prefix given" do
-        outcome = SearchAccounts.call("jst").outputs.accounts.all
+        outcome = SearchAccounts.call("jst").outputs.items
         expect(outcome).to eq [account_4, account_3, account_1]
       end
 
       it "should match any field when no prefix given and intersect when prefix given" do
-        outcome = SearchAccounts.call("jst username:jst").outputs.accounts.all
+        outcome = SearchAccounts.call("jst username:jst").outputs.items
         expect(outcome).to eq [account_3, account_1]
       end
 
-      it "shouldn't allow accounts to add their own wildcards" do
-        outcome = SearchAccounts.call("username:'%ar'").outputs.accounts.all
+      it "shouldn't allow users to add their own wildcards" do
+        outcome = SearchAccounts.call("username:'%ar'").outputs.items
         expect(outcome).to eq []
       end
 
-      it "should gather space-separated unprefixed search terms" do
-        outcome = SearchAccounts.call("john mighty").outputs.accounts.all
+      it "should gather comma-separated unprefixed search terms" do
+        outcome = SearchAccounts.call("john,mighty").outputs.items
         expect(outcome).to eq [account_3, account_1, account_2]
       end
 
+      it "should not gather space-separated unprefixed search terms" do
+        outcome = SearchAccounts.call("john mighty").outputs.items
+        expect(outcome).to eq []
+      end
+
       context "pagination and sorting" do
 
         let!(:billy_accounts) {
@@ -80,31 +85,26 @@ module OpenStax
           }
         }
 
-        it "should return the first page of values by default in default order" do
-          outcome = SearchAccounts.call("username:billy").outputs.accounts.all
+        it "should return the first page of values by default when requested" do
+          outcome = SearchAccounts.call("username:billy", per_page: 20).outputs.items
           expect(outcome.length).to eq 20
           expect(outcome[0]).to eq Account.where{username.eq "billy_00"}.first
           expect(outcome[19]).to eq Account.where{username.eq "billy_19"}.first
         end
 
-        it "should return the 2nd page when requested" do
-          outcome = SearchAccounts.call("username:billy", page: 1).outputs.accounts.all
+        it "should return the second page when requested" do
+          outcome = SearchAccounts.call("username:billy", page: 2, per_page: 20).outputs.items
           expect(outcome.length).to eq 20
           expect(outcome[0]).to eq Account.where{username.eq "billy_20"}.first
           expect(outcome[19]).to eq Account.where{username.eq "billy_39"}.first
         end
 
         it "should return the incomplete 3rd page when requested" do
-          outcome = SearchAccounts.call("username:billy", page: 2).outputs.accounts.all
+          outcome = SearchAccounts.call("username:billy", page: 3, per_page: 20).outputs.items
           expect(outcome.length).to eq 6
           expect(outcome[5]).to eq Account.where{username.eq "billy_45"}.first
         end
 
-        it "should return no results if the limit is exceeded" do
-          outcome = SearchAccounts.call("").outputs.accounts.all
-          expect(outcome).to be_empty
-        end
-
       end
 
       context "sorting" do
@@ -114,10 +114,10 @@ module OpenStax
         let!(:tim_jones) { FactoryGirl.create :openstax_accounts_account, first_name: "Tim", last_name: "Jones", username: "foo_tj" }
 
         it "should allow sort by multiple fields in different directions" do
-          outcome = SearchAccounts.call("username:foo", order_by: "first_name, last_name DESC").outputs.accounts.all
+          outcome = SearchAccounts.call("username:foo", order_by: "first_name, last_name DESC").outputs.items
           expect(outcome).to eq [bob_jones, bob_brown, tim_jones]
 
-          outcome = SearchAccounts.call("username:foo", order_by: "first_name, last_name ASC").outputs.accounts.all
+          outcome = SearchAccounts.call("username:foo", order_by: "first_name, last_name ASC").outputs.items
           expect(outcome).to eq [bob_brown, bob_jones, tim_jones]
         end