RubyGems - openstax_accounts - Versions diffs - 7.13.0 → 8.1.1 - Mend

openstax_accounts 7.13.0 → 8.1.1

Files changed (120) hide show

data/spec/dummy/public/404.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>The page you were looking for doesn't exist (404)</title>
-  <style type="text/css">
-    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
-    div.dialog {
-      width: 25em;
-      padding: 0 4em;
-      margin: 4em auto 0 auto;
-      border: 1px solid #ccc;
-      border-right-color: #999;
-      border-bottom-color: #999;
-    }
-    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
-  </style>
-</head>
-<body>
-  <!-- This file lives in public/404.html -->
-  <div class="dialog">
-    <h1>The page you were looking for doesn't exist.</h1>
-    <p>You may have mistyped the address or the page may have moved.</p>
-  </div>
-</body>
-</html>

data/spec/dummy/public/422.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>The change you wanted was rejected (422)</title>
-  <style type="text/css">
-    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
-    div.dialog {
-      width: 25em;
-      padding: 0 4em;
-      margin: 4em auto 0 auto;
-      border: 1px solid #ccc;
-      border-right-color: #999;
-      border-bottom-color: #999;
-    }
-    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
-  </style>
-</head>
-<body>
-  <!-- This file lives in public/422.html -->
-  <div class="dialog">
-    <h1>The change you wanted was rejected.</h1>
-    <p>Maybe you tried to change something you didn't have access to.</p>
-  </div>
-</body>
-</html>

data/spec/dummy/public/500.html DELETED Viewed

@@ -1,25 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>We're sorry, but something went wrong (500)</title>
-  <style type="text/css">
-    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
-    div.dialog {
-      width: 25em;
-      padding: 0 4em;
-      margin: 4em auto 0 auto;
-      border: 1px solid #ccc;
-      border-right-color: #999;
-      border-bottom-color: #999;
-    }
-    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
-  </style>
-</head>
-<body>
-  <!-- This file lives in public/500.html -->
-  <div class="dialog">
-    <h1>We're sorry, but something went wrong.</h1>
-  </div>
-</body>
-</html>

data/spec/dummy/public/favicon.ico DELETED Viewed

File without changes

data/spec/dummy/script/rails DELETED Viewed

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
-require 'rails/commands'

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

@@ -1,63 +0,0 @@
-require 'spec_helper'
-module OpenStax
-  module Accounts
-    RSpec.describe AccountsSearch do
-      let!(:account_1)          { FactoryBot.create :openstax_accounts_account,
-                                                  first_name: 'John',
-                                                  last_name: 'Stravinsky',
-                                                  username: 'jstrav' }
-      let!(:account_2)          { FactoryBot.create :openstax_accounts_account,
-                                                  first_name: 'Mary',
-                                                  last_name: 'Mighty',
-                                                  full_name: 'Mary Mighty',
-                                                  username: 'mary' }
-      let!(:account_3)          { FactoryBot.create :openstax_accounts_account,
-                                                  first_name: 'John',
-                                                  last_name: 'Stead',
-                                                  username: 'jstead' }
-      let!(:account_4)          { FactoryBot.create :openstax_accounts_account,
-                                                  first_name: 'Bob',
-                                                  last_name: 'JST',
-                                                  username: 'bigbear' }
-      let!(:billy_accounts) {
-        (0..49).to_a.collect{|ii|
-          FactoryBot.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 DELETED Viewed

@@ -1,55 +0,0 @@
-require 'spec_helper'
-module OpenStax
-  module Accounts
-    RSpec.describe Dev::AccountsSearch do
-      let!(:account_1)          { FactoryBot.create :openstax_accounts_account,
-                                                  first_name: 'John',
-                                                  last_name: 'Stravinsky',
-                                                  username: 'jstrav' }
-      let!(:account_2)          { FactoryBot.create :openstax_accounts_account,
-                                                  first_name: 'Mary',
-                                                  last_name: 'Mighty',
-                                                  full_name: 'Mary Mighty',
-                                                  username: 'mary' }
-      let!(:account_3)          { FactoryBot.create :openstax_accounts_account,
-                                                  first_name: 'John',
-                                                  last_name: 'Stead',
-                                                  username: 'jstead' }
-      let!(:account_4)          { FactoryBot.create :openstax_accounts_account,
-                                                  first_name: 'Bob',
-                                                  last_name: 'JST',
-                                                  username: 'bigbear' }
-      let!(:billy_accounts) {
-        (0..49).to_a.collect{|ii|
-          FactoryBot.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/handlers/openstax/accounts/sessions_callback_spec.rb DELETED Viewed

@@ -1,119 +0,0 @@
-require 'spec_helper'
-module OpenStax
-  module Accounts
-    RSpec.describe SessionsCallback do
-      it "deals with null faculty_status" do
-        with_stubbing(false) do
-          request = mock_omniauth_request
-          remove_nickname!(request)
-          result = described_class.handle(request: request)
-          expect(result.outputs.account).to be_valid
-          expect(result.outputs.account).to be_persisted
-        end
-      end
-      context "uuid" do
-        it "sets the UUID on the account" do
-          uuid = SecureRandom.uuid
-          result = described_class.handle(request: mock_omniauth_request(uuid: uuid))
-          expect(result.outputs.account.uuid).to eq uuid
-        end
-      end
-      context "support_identifier" do
-        it "sets the support_identifier on the account" do
-          support_identifier = "cs_#{SecureRandom.hex(4)}"
-          result = described_class.handle(
-            request: mock_omniauth_request(support_identifier: support_identifier)
-          )
-          expect(result.outputs.account.support_identifier).to eq support_identifier
-        end
-      end
-      context "faculty_status" do
-        it "defaults to no_faculty_info if the received faculty_status is unknown" +
-           " (e.g. if Accounts is updated but this repo is not)" do
-          result = described_class.handle(
-            request: mock_omniauth_request(faculty_status: "howdy_ho")
-          )
-          expect(result.outputs.account).to be_no_faculty_info
-        end
-        it "defaults to no_faculty_info if faculty status is not present" do
-          request = mock_omniauth_request()
-          remove_faculty_status!(request)
-          result = described_class.handle(request: request)
-          expect(result.outputs.account).to be_no_faculty_info
-        end
-      end
-      context "role" do
-        it "sets the role on the account" do
-          result = described_class.handle(
-            request: mock_omniauth_request(self_reported_role: "instructor")
-          )
-          expect(result.outputs.account).to be_instructor
-        end
-        it "deals with unknown role (e.g. if Accounts update but this repo not)" do
-          result = described_class.handle(
-            request: mock_omniauth_request(self_reported_role: "howdy_ho")
-          )
-          expect(result.outputs.account).to be_unknown_role
-        end
-      end
-      context "school_type" do
-        it "sets the school_type on the account" do
-          result = described_class.handle(
-            request: mock_omniauth_request(school_type: "college")
-          )
-          expect(result.outputs.account).to be_college
-        end
-        it "deals with unknown school_type (e.g. if Accounts update but this repo not)" do
-          result = described_class.handle(
-            request: mock_omniauth_request(school_type: "howdy_ho")
-          )
-          expect(result.outputs.account).to be_unknown_school_type
-        end
-      end
-      context "user exists" do
-        it "updates the user's data" do
-          existing_account = FactoryBot.create :openstax_accounts_account
-          uuid = SecureRandom.uuid
-          support_identifier = "cs_#{SecureRandom.hex(4)}"
-          result = described_class.handle(
-            request: mock_omniauth_request(
-              uid: existing_account.openstax_uid,
-              first_name: "1234",
-              last_name: "5678",
-              title: "900",
-              nickname: "191919",
-              faculty_status: "confirmed_faculty",
-              uuid: uuid,
-              support_identifier: support_identifier,
-              self_reported_role: "instructor")
-          )
-          account = result.outputs.account.reload
-          expect(account.id).to eq existing_account.id
-          expect(account.first_name).to eq "1234"
-          expect(account.last_name).to eq "5678"
-          expect(account.title).to eq "900"
-          expect(account.username).to eq "191919"
-          expect(account).to be_confirmed_faculty
-          expect(account.uuid).to eq uuid
-          expect(account.support_identifier).to eq support_identifier
-          expect(account).to be_instructor
-        end
-      end
-    end
-  end
-end

data/spec/lib/openstax/accounts/api_spec.rb DELETED Viewed

@@ -1,212 +0,0 @@
-require 'spec_helper'
-module OpenStax
-  module Accounts
-    RSpec.describe Api do
-      let!(:account) { OpenStax::Accounts::Account.create(username: 'some_user',
-                         first_name: 'Some', last_name: 'User', full_name: 'SomeUser',
-                         title: 'Sir', openstax_uid: 1, access_token: 'secret') }
-      def reset(controller)
-        controller.last_action = nil
-        controller.last_json = nil
-        controller.last_params = nil
-      end
-      it 'makes api requests' do
-        reset(::Api::DummyController)
-        Api.request(:post, 'dummy', :params => {:test => true})
-        expect(::Api::DummyController.last_action).to eq :dummy
-        expect(::Api::DummyController.last_params).to include 'test' => 'true'
-      end
-      context 'users' do
-        before(:each) { reset(::Api::UsersController) }
-        let!(:account) { FactoryBot.create :openstax_accounts_account }
-        it 'makes api call to users index' do
-          Api.search_accounts('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.update_account(account)
-          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
-        it 'makes api call to (temp) user create by email' do
-          Api.find_or_create_account(email: 'dummy@dum.my')
-          expect(::Api::UsersController.last_action).to eq :create
-          expect(::Api::UsersController.last_json).to(
-            include('email' => 'dummy@dum.my')
-          )
-        end
-        it 'makes api call to (temp) user create by username' do
-          Api.find_or_create_account(username: 'dummy')
-          expect(::Api::UsersController.last_action).to eq :create
-          expect(::Api::UsersController.last_json).to(
-            include('username' => 'dummy')
-          )
-        end
-      end
-      context 'application_users' do
-        before(:each) { reset(::Api::ApplicationUsersController) }
-        it 'makes api call to application_users index' do
-          Api.search_application_accounts('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.get_application_account_updates
-          expect(::Api::ApplicationUsersController.last_action).to eq :updates
-          expect(::Api::ApplicationUsersController.last_params).to include limit: "250"
-        end
-        it 'does not limit updates call if param blank' do
-          allow(OpenStax::Accounts.configuration).to receive(:max_user_updates_per_request) { "" }
-          Api.get_application_account_updates
-          expect(::Api::ApplicationUsersController.last_action).to eq :updates
-          expect(::Api::ApplicationUsersController.last_params.keys).not_to include "limit"
-        end
-        it 'makes api call to application_users updated' do
-          Api.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(
-            {'id' => 1, 'read_updates' => 1})
-        end
-      end
-      context 'groups' do
-        before(:each) { reset(::Api::GroupsController) }
-        let!(:account) { FactoryBot.create :openstax_accounts_account }
-        let!(:group)   { FactoryBot.create :openstax_accounts_group }
-        it 'makes api call to groups create' do
-          Api.create_group(account, group)
-          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.update_group(account, group)
-          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(
-            {'name' => group.name, 'is_public' => group.is_public})
-        end
-        it 'makes api call to group destroy' do
-          group.save!
-          Api.destroy_group(account, group)
-          expect(::Api::GroupsController.last_action).to eq :destroy
-          expect(::Api::GroupsController.last_params).to include(
-            {'id' => group.openstax_uid.to_s})
-        end
-      end
-      context 'group_members' do
-        before(:each) { reset(::Api::GroupMembersController) }
-        let!(:account) { FactoryBot.create :openstax_accounts_account }
-        let!(:group_member)   { FactoryBot.build :openstax_accounts_group_member }
-        it 'makes api call to group_members create' do
-          Api.create_group_member(account, group_member)
-          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.destroy_group_member(account, group_member)
-          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
-      end
-      context 'group_owners' do
-        before(:each) { reset(::Api::GroupOwnersController) }
-        let!(:account)      { FactoryBot.create :openstax_accounts_account }
-        let!(:group_owner) { FactoryBot.build :openstax_accounts_group_owner }
-        it 'makes api call to group_owners create' do
-          Api.create_group_owner(account, group_owner)
-          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.destroy_group_owner(account, group_owner)
-          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
-      end
-      context 'group_nestings' do
-        before(:each) { reset(::Api::GroupNestingsController) }
-        let!(:account)      { FactoryBot.create :openstax_accounts_account }
-        let!(:group_nesting) { FactoryBot.build :openstax_accounts_group_nesting }
-        it 'makes api call to group_nestings (create)' do
-          Api.create_group_nesting(account, group_nesting)
-          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.destroy_group_nesting(account, group_nesting)
-          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
-      end
-      context 'application_groups' do
-        before(:each) { reset(::Api::ApplicationGroupsController) }
-        it 'makes api call to application_groups_updates' do
-          Api.get_application_group_updates
-          expect(::Api::ApplicationGroupsController.last_action).to eq :updates
-        end
-        it 'makes api call to application_groups_updated' do
-          Api.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(
-            {'id' => 1, 'read_updates' => 1})
-        end
-      end
-    end
-  end
-end