openstax_utilities 4.1.0 → 4.3.0

data/spec/factories/user.rb

@@ -1,4 +1,4 @@
-FactoryGirl.define do
+FactoryBot.define do
   factory :user do
     username { SecureRandom.hex.to_s }
     password_hash { SecureRandom.hex.to_s }

data/spec/lib/openstax/utilities/access_policy_spec.rb

@@ -5,7 +5,7 @@ module OpenStax
 
     describe AccessPolicy do
 
-      let!(:user) { FactoryGirl.create :user }
+      let!(:user) { FactoryBot.create :user }
 
       it 'responds to any _allowed? calls' do
         AccessPolicy.register(User, DummyAccessPolicy)
@@ -24,30 +24,31 @@ module OpenStax
 
       it 'delegates checks to policy classes based on resource class' do
         dummy_object = double('Dummy')
-        dummy_policy = double('Dummy Policy', :action_allowed? => true)
 
         AccessPolicy.register(User, DummyAccessPolicy)
-        AccessPolicy.register(dummy_object.class, dummy_policy)
+        AccessPolicy.register(dummy_object.class, DummierAccessPolicy)
         
         DummyAccessPolicy.last_action = nil
         DummyAccessPolicy.last_requestor = nil
         DummyAccessPolicy.last_resource = nil
 
-        expect(AccessPolicy.action_allowed?(:read, user, dummy_object)).to(
-          eq(true))
-      
-        expect{AccessPolicy.require_action_allowed!(:read, user, dummy_object)
-          }.not_to raise_error
+        DummierAccessPolicy.last_action = nil
+        DummierAccessPolicy.last_requestor = nil
+        DummierAccessPolicy.last_resource = nil
 
-        expect(DummyAccessPolicy.last_action).to be_nil
-        expect(DummyAccessPolicy.last_requestor).to be_nil
-        expect(DummyAccessPolicy.last_resource).to be_nil
+        expect(AccessPolicy.action_allowed?(:read, user, dummy_object)).to eq true
+        expect{
+          AccessPolicy.require_action_allowed!(:read, user, dummy_object)
+        }.not_to raise_error
 
-        expect(AccessPolicy.action_allowed?(:create, user, User.new)).to(
-          eq(true))
+        expect(DummierAccessPolicy.last_action).to eq(:read)
+        expect(DummierAccessPolicy.last_requestor).to eq(user)
+        expect(DummierAccessPolicy.last_resource).to eq(dummy_object)
 
-        expect{AccessPolicy.require_action_allowed!(:create, user, User.new)
-          }.not_to raise_error
+        expect(AccessPolicy.action_allowed?(:create, user, User.new)).to eq true
+        expect{
+          AccessPolicy.require_action_allowed!(:create, user, User.new)
+        }.not_to raise_error
 
         expect(DummyAccessPolicy.last_action).to eq(:create)
         expect(DummyAccessPolicy.last_requestor).to eq(user)

data/spec/lib/openstax/utilities/assets_spec.rb

@@ -0,0 +1,40 @@
+require 'rails_helper'
+require 'vcr_helper'
+
+RSpec.describe OpenStax::Utilities::Assets, vcr: VCR_OPTS do
+  before { RequestStore.store[:assets_manifest] = nil }
+
+  it 'defaults to name.js when manifest is missing' do
+    expect_any_instance_of(Faraday::Connection).to receive(:get).and_return(
+      OpenStruct.new success?: false
+    )
+    expect(described_class.tags_for(:foo)).to include "src='http://localhost:8000/dist/foo.js'"
+  end
+
+  it 'reads asset url from manifest' do
+    expect_any_instance_of(Faraday::Connection).to receive(:get).and_return(
+      OpenStruct.new(
+        success?: true,
+        body: { entrypoints: { foo: { js: [ 'foo-732c56c32ff399b62.min.bar' ] } } }.to_json
+      )
+    )
+    expect(described_class.tags_for(:foo)).to include(
+      "src='http://localhost:8000/dist/foo-732c56c32ff399b62.min.bar'"
+    )
+  end
+
+  context 'loading remote manifest' do
+    before do
+      @previous_assets_url = Rails.application.secrets.assets_url
+      Rails.application.secrets.assets_url = 'https://tutor-dev.openstax.org/assets'
+    end
+    after  { Rails.application.secrets.assets_url = @previous_assets_url }
+
+    it 'uses remote json' do
+      expect(described_class.manifest).to be_kind_of described_class::Manifest
+      expect(described_class.tags_for(:tutor)).to(
+        eq "<script type='text/javascript' src='https://tutor-dev.openstax.org/assets/tutor-b920eb0be760a7c440bf.min.js' crossorigin='anonymous' async></script>"
+      )
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -3,9 +3,8 @@ ENV["RAILS_ENV"] ||= 'test'
 require 'spec_helper'
 require File.expand_path("../dummy/config/environment", __FILE__)
 require 'rspec/rails'
-require 'factory_girl_rails'
+require 'factory_bot_rails'
 require 'faker'
-require 'squeel'
 
 # Add additional requires below this line. Rails is not loaded until this point!
 

data/spec/routines/openstax/utilities/limit_and_paginate_relation_spec.rb

@@ -0,0 +1,72 @@
+require 'rails_helper'
+
+module OpenStax
+  module Utilities
+    describe SearchRelation do
+
+      let!(:john_doe) { FactoryBot.create :user, name: "John Doe",
+                                           username: "doejohn",
+                                           email: "john@doe.com" }
+
+      let!(:jane_doe) { FactoryBot.create :user, name: "Jane Doe",
+                                           username: "doejane",
+                                           email: "jane@doe.com" }
+
+      let!(:jack_doe) { FactoryBot.create :user, name: "Jack Doe",
+                                           username: "doejack",
+                                           email: "jack@doe.com" }
+
+      before(:each) do
+        100.times do
+          FactoryBot.create(:user)
+        end
+
+        @relation = User.unscoped
+      end
+
+      it "returns nothing if too many results" do
+        routine = LimitAndPaginateRelation.call(relation: @relation,
+                                                max_items: 10)
+        outputs = routine.outputs
+        errors = routine.errors
+        expect(outputs).not_to be_empty
+        expect(outputs[:total_count]).to eq User.count
+        expect(outputs[:items]).to be_empty
+        expect(errors).not_to be_empty
+        expect(errors.first.code).to eq :too_many_items
+      end
+
+      it "paginates results" do
+        all_items = @relation.to_a
+
+        items = LimitAndPaginateRelation.call(relation: @relation,
+                                              per_page: 20).outputs[:items]
+        expect(items.limit(nil).offset(nil).count).to eq all_items.count
+        expect(items.limit(nil).offset(nil).to_a).to eq all_items
+        expect(items.count).to eq 20
+        expect(items.to_a).to eq all_items[0..19]
+
+        for page in 1..5
+          items = LimitAndPaginateRelation.call(relation: @relation,
+                                                page: page,
+                                                per_page: 20)
+                                          .outputs[:items]
+          expect(items.limit(nil).offset(nil).count).to eq all_items.count
+          expect(items.limit(nil).offset(nil).to_a).to eq all_items
+          expect(items.count).to eq 20
+          expect(items.to_a).to eq all_items.slice(20*(page-1), 20)
+        end
+
+        items = LimitAndPaginateRelation.call(relation: @relation,
+                                              page: 1000,
+                                              per_page: 20)
+                                        .outputs[:items]
+        expect(items.limit(nil).offset(nil).count).to eq all_items.count
+        expect(items.limit(nil).offset(nil).to_a).to eq all_items
+        expect(items.count).to eq 0
+        expect(items.to_a).to be_empty
+      end
+
+    end
+  end
+end

data/spec/routines/openstax/utilities/order_relation_spec.rb

@@ -0,0 +1,55 @@
+require 'rails_helper'
+
+module OpenStax
+  module Utilities
+    describe SearchRelation do
+      let!(:john_doe) do
+        FactoryBot.create :user, name: "John Doe", username: "doejohn", email: "john@doe.com"
+      end
+
+      let!(:jane_doe) do
+        FactoryBot.create :user, name: "Jane Doe", username: "doejane", email: "jane@doe.com"
+      end
+
+      let!(:jack_doe) do
+        FactoryBot.create :user, name: "Jack Doe", username: "doejack", email: "jack@doe.com"
+      end
+
+      before(:each) do
+        100.times { FactoryBot.create(:user) }
+
+        @relation = User.where(User.arel_table[:username].matches('doe%'))
+      end
+
+      it "orders results by multiple fields in different directions" do
+        items = OrderRelation.call(
+          relation: @relation,
+          sortable_fields: SearchUsers::SORTABLE_FIELDS,
+          order_by: 'cReAtEd_At AsC, iD'
+        ).outputs[:items]
+        expect(items).to include(john_doe)
+        expect(items).to include(jane_doe)
+        expect(items).to include(jack_doe)
+        john_index = items.index(john_doe)
+        jane_index = items.index(jane_doe)
+        jack_index = items.index(jack_doe)
+        expect(jane_index).to be > john_index
+        expect(jack_index).to be > jane_index
+
+        items = OrderRelation.call(
+          relation: @relation,
+          sortable_fields: SearchUsers::SORTABLE_FIELDS,
+          order_by: 'CrEaTeD_aT dEsC, Id DeSc'
+        ).outputs[:items]
+        expect(items).to include(john_doe)
+        expect(items).to include(jane_doe)
+        expect(items).to include(jack_doe)
+        john_index = items.index(john_doe)
+        jane_index = items.index(jane_doe)
+        jack_index = items.index(jack_doe)
+        expect(jane_index).to be < john_index
+        expect(jack_index).to be < jane_index
+      end
+    end
+  end
+end

data/spec/routines/openstax/utilities/{abstract_keyword_search_routine_spec.rb → search_and_organize_relation_spec.rb}

@@ -2,28 +2,36 @@ require 'rails_helper'
 
 module OpenStax
   module Utilities
-    describe AbstractKeywordSearchRoutine do
+    describe SearchAndOrganizeRelation do
 
-      let!(:john_doe) { FactoryGirl.create :user, name: "John Doe",
+      OPTIONS = {
+        relation: SearchUsers::RELATION,
+        search_proc: SearchUsers::SEARCH_PROC,
+        sortable_fields: SearchUsers::SORTABLE_FIELDS,
+        max_items: SearchUsers::MAX_ITEMS
+      }
+
+      let!(:john_doe) { FactoryBot.create :user, name: "John Doe",
                                            username: "doejohn",
                                            email: "john@doe.com" }
 
-      let!(:jane_doe) { FactoryGirl.create :user, name: "Jane Doe",
+      let!(:jane_doe) { FactoryBot.create :user, name: "Jane Doe",
                                            username: "doejane",
                                            email: "jane@doe.com" }
 
-      let!(:jack_doe) { FactoryGirl.create :user, name: "Jack Doe",
+      let!(:jack_doe) { FactoryBot.create :user, name: "Jack Doe",
                                            username: "doejack",
                                            email: "jack@doe.com" }
 
       before(:each) do
         100.times do
-          FactoryGirl.create(:user)
+          FactoryBot.create(:user)
         end
       end
 
-      it "filters results based on one field" do
-        items = SearchUsers.call(User.unscoped, 'last_name:dOe').outputs[:items]
+      it "filters results" do
+        items = SearchAndOrganizeRelation.call(OPTIONS.merge(params: {
+                  q: 'last_name:dOe'})).outputs[:items]
 
         expect(items).to include(john_doe)
         expect(items).to include(jane_doe)
@@ -31,11 +39,9 @@ module OpenStax
         items.each do |item|
           expect(item.name.downcase).to match(/\A[\w]* doe[\w]*\z/i)
         end
-      end
 
-      it "filters results based on multiple fields" do
-        items = SearchUsers.call(User.unscoped, 'first_name:jOhN last_name:DoE')
-                           .outputs[:items]
+        items = SearchAndOrganizeRelation.call(OPTIONS.merge(params: {
+                  q: 'first_name:jOhN last_name:DoE'})).outputs[:items]
 
         expect(items).to include(john_doe)
         expect(items).not_to include(jane_doe)
@@ -43,11 +49,9 @@ module OpenStax
         items.each do |item|
           expect(item.name).to match(/\Ajohn[\w]* doe[\w]*\z/i)
         end
-      end
 
-      it "filters results based on multiple keywords per field" do
-        items = SearchUsers.call(User.unscoped, 'first_name:JoHn,JaNe last_name:dOe')
-                           .outputs[:items]
+        items = SearchAndOrganizeRelation.call(OPTIONS.merge(params: {
+                  q: 'first_name:JoHn,JaNe last_name:dOe'})).outputs[:items]
 
         expect(items).to include(john_doe)
         expect(items).to include(jane_doe)
@@ -57,22 +61,10 @@ module OpenStax
         end
       end
 
-      it "filters scoped results" do
-        items = SearchUsers.call(User.where{name.like 'jOhN%'},
-                                 'last_name:dOe').outputs[:items]
-
-        expect(items).to include(john_doe)
-        expect(items).not_to include(jane_doe)
-        expect(items).not_to include(jack_doe)
-        items.each do |item|
-          expect(item.name.downcase).to match(/\Ajohn[\w]* doe[\w]*\z/i)
-        end
-      end
-
-      it "orders results by multiple fields in different directions" do
-        items = SearchUsers.call(User.unscoped, 'username:DoE',
-                                 order_by: 'cReAtEd_At AsC, iD')
-                          .outputs[:items]
+      it "orders results" do
+        items = SearchAndOrganizeRelation.call(OPTIONS.merge(params: {
+                    order_by: 'cReAtEd_At AsC, iD',
+                    q: 'username:dOe'})).outputs[:items].to_a
         expect(items).to include(john_doe)
         expect(items).to include(jane_doe)
         expect(items).to include(jack_doe)
@@ -81,13 +73,10 @@ module OpenStax
         jack_index = items.index(jack_doe)
         expect(jane_index).to be > john_index
         expect(jack_index).to be > jane_index
-        items.each do |item|
-          expect(item.username).to match(/\Adoe[\w]*\z/i)
-        end
 
-        items = SearchUsers.call(User.unscoped, 'username:dOe',
-                                 order_by: 'CrEaTeD_aT dEsC, Id DeSc')
-                          .outputs[:items]
+        items = SearchAndOrganizeRelation.call(OPTIONS.merge(params: {
+                  order_by: 'CrEaTeD_aT dEsC, Id DeSc',
+                  q: 'username:dOe'})).outputs[:items].to_a
         expect(items).to include(john_doe)
         expect(items).to include(jane_doe)
         expect(items).to include(jack_doe)
@@ -96,31 +85,49 @@ module OpenStax
         jack_index = items.index(jack_doe)
         expect(jane_index).to be < john_index
         expect(jack_index).to be < jane_index
-        items.each do |item|
-          expect(item.username).to match(/\Adoe[\w]*\z/i)
-        end
+      end
+
+      it "returns nothing if too many results" do
+        routine = SearchAndOrganizeRelation.call(OPTIONS.merge(params: {
+                    q: ''}))
+        outputs = routine.outputs
+        errors = routine.errors
+        expect(outputs).not_to be_empty
+        expect(outputs[:total_count]).to eq User.count
+        expect(outputs[:items]).to be_empty
+        expect(errors).not_to be_empty
+        expect(errors.first.code).to eq :too_many_items
       end
 
       it "paginates results" do
-        all_items = SearchUsers.call(User.unscoped, '').outputs[:items].to_a
+        all_items = SearchUsers::RELATION.to_a
 
-        items = SearchUsers.call(User.unscoped, '', per_page: 20).outputs[:items]
-        expect(items.limit(nil).offset(nil).count).to eq all_items.count
+        items = SearchAndOrganizeRelation.call(OPTIONS
+                  .except(:max_items)
+                  .merge(params: {q: '',
+                                  per_page: 20})).outputs[:items]
+        expect(items.limit(nil).offset(nil).count).to eq all_items.length
         expect(items.limit(nil).offset(nil).to_a).to eq all_items
         expect(items.count).to eq 20
         expect(items.to_a).to eq all_items[0..19]
 
         for page in 1..5
-          items = SearchUsers.call(User.unscoped, '', page: page, per_page: 20)
-                             .outputs[:items]
+          items = SearchAndOrganizeRelation.call(OPTIONS
+                    .except(:max_items)
+                    .merge(params: {q: '',
+                                    page: page,
+                                    per_page: 20})).outputs[:items]
           expect(items.limit(nil).offset(nil).count).to eq all_items.count
           expect(items.limit(nil).offset(nil).to_a).to eq all_items
           expect(items.count).to eq 20
           expect(items.to_a).to eq all_items.slice(20*(page-1), 20)
         end
 
-        items = SearchUsers.call(User.unscoped, '', page: 1000, per_page: 20)
-                           .outputs[:items]
+        items = SearchAndOrganizeRelation.call(OPTIONS
+                  .except(:max_items)
+                  .merge(params: {q: '',
+                                  page: 1000,
+                                  per_page: 20})).outputs[:items]
         expect(items.limit(nil).offset(nil).count).to eq all_items.count
         expect(items.limit(nil).offset(nil).to_a).to eq all_items
         expect(items.count).to eq 0

data/spec/routines/openstax/utilities/search_relation_spec.rb

@@ -0,0 +1,81 @@
+require 'rails_helper'
+
+module OpenStax
+  module Utilities
+    describe SearchRelation do
+      let!(:john_doe) do
+        FactoryBot.create :user, name: "John Doe", username: "doejohn", email: "john@doe.com"
+      end
+
+      let!(:jane_doe) do
+        FactoryBot.create :user, name: "Jane Doe", username: "doejane", email: "jane@doe.com"
+      end
+
+      let!(:jack_doe) do
+        FactoryBot.create :user, name: "Jack Doe", username: "doejack", email: "jack@doe.com"
+      end
+
+      before(:each) do
+        100.times do
+          FactoryBot.create(:user)
+        end
+      end
+
+      it "filters results based on one field" do
+        items = SearchRelation.call(relation: SearchUsers::RELATION,
+                                    search_proc: SearchUsers::SEARCH_PROC,
+                                    query: 'last_name:dOe').outputs[:items]
+
+        expect(items).to include(john_doe)
+        expect(items).to include(jane_doe)
+        expect(items).to include(jack_doe)
+        items.each do |item|
+          expect(item.name.downcase).to match(/\A[\w]* doe[\w]*\z/i)
+        end
+      end
+
+      it "filters results based on multiple fields" do
+        items = SearchRelation.call(relation: SearchUsers::RELATION,
+                                    search_proc: SearchUsers::SEARCH_PROC,
+                                    query: 'first_name:jOhN last_name:DoE')
+                              .outputs[:items]
+
+        expect(items).to include(john_doe)
+        expect(items).not_to include(jane_doe)
+        expect(items).not_to include(jack_doe)
+        items.each do |item|
+          expect(item.name).to match(/\Ajohn[\w]* doe[\w]*\z/i)
+        end
+      end
+
+      it "filters results based on multiple keywords per field" do
+        items = SearchRelation.call(relation: SearchUsers::RELATION,
+                                    search_proc: SearchUsers::SEARCH_PROC,
+                                    query: 'first_name:JoHn,JaNe last_name:dOe')
+                           .outputs[:items]
+
+        expect(items).to include(john_doe)
+        expect(items).to include(jane_doe)
+        expect(items).not_to include(jack_doe)
+        items.each do |item|
+          expect(item.name).to match(/\A[john|jane][\w]* doe[\w]*\z/i)
+        end
+      end
+
+      it "filters scoped results" do
+        items = SearchRelation.call(
+          relation: User.where(User.arel_table[:name].matches('jOhN%')),
+          search_proc: SearchUsers::SEARCH_PROC,
+          query: 'last_name:dOe'
+        ).outputs[:items]
+
+        expect(items).to include(john_doe)
+        expect(items).not_to include(jane_doe)
+        expect(items).not_to include(jack_doe)
+        items.each do |item|
+          expect(item.name.downcase).to match(/\Ajohn[\w]* doe[\w]*\z/i)
+        end
+      end
+    end
+  end
+end