canvas-lms/spec/spec_helper.rb

#
# Copyright (C) 2011 Instructure, Inc.
#
# This file is part of Canvas.
#
# Canvas is free software: you can redistribute it and/or modify it under
# the terms of the GNU Affero General Public License as published by the Free
# Software Foundation, version 3 of the License.
#
# Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
#

begin
  require RUBY_VERSION >= '2.0.0' ? 'byebug' : 'debugger'
rescue LoadError
end

require 'securerandom'

RSpec.configure do |c|
  c.raise_errors_for_deprecations!
  c.color = true

  c.around(:each) do |example|
    attempts = 0
    begin
      Timeout::timeout(180) {
        example.run
      }
      if ENV['AUTORERUN']
        e = @example.instance_variable_get('@exception')
        if !e.nil? && (attempts += 1) < 2 && !example.metadata[:no_retry]
          puts "FAILURE: #{@example.description} \n #{e}".red
          puts "RETRYING: #{@example.description}".yellow
          @example.instance_variable_set('@exception', nil)
          redo
        elsif e.nil? && attempts != 0
          puts "SUCCESS: retry passed for \n #{@example.description}".green
        end
      end
    end until true
  end
end

begin
  ; require File.expand_path(File.dirname(__FILE__) + "/../parallelized_specs/lib/parallelized_specs.rb");
rescue LoadError;
end

ENV["RAILS_ENV"] = 'test'

require File.expand_path('../../config/environment', __FILE__) unless defined?(Rails)
require 'rspec/rails'

Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }

ActionView::TestCase::TestController.view_paths = ApplicationController.view_paths

module RSpec::Rails
  module ViewExampleGroup
    module ExampleMethods
      # normally in rspec 2, assigns returns a newly constructed hash
      # which means that 'assigns[:key] = value' in view specs does nothing
      def assigns
        @assigns ||= super
      end

      alias :view_assigns :assigns

      delegate :content_for, :to => :view

      def render_with_helpers(*args)
        controller_class = ("#{@controller.controller_path.camelize}Controller".constantize rescue nil) || ApplicationController

        controller_class.instance_variable_set(:@js_env, nil)
        # this extends the controller's helper methods to the view
        # however, these methods are delegated to the test controller
        view.singleton_class.class_eval do
          include controller_class._helpers unless included_modules.include?(controller_class._helpers)
        end

        # so create a "real_controller"
        # and delegate the helper methods to it
        @controller.singleton_class.class_eval do
          attr_accessor :real_controller

          controller_class._helper_methods.each do |helper|
            delegate helper, :to => :real_controller
          end
        end

        real_controller = controller_class.new
        real_controller.instance_variable_set(:@_request, @controller.request)
        @controller.real_controller = real_controller

        # just calling "render 'path/to/view'" by default looks for a partial
        if args.first && args.first.is_a?(String)
          file = args.shift
          args = [{:template => file}] + args
        end
        render_without_helpers(*args)
      end

      alias_method_chain :render, :helpers
    end
  end

  module Matchers
    class HaveTag
      include ActionDispatch::Assertions::SelectorAssertions
      include Test::Unit::Assertions

      def initialize(expected)
        @expected = expected
      end

      def matches?(html, &block)
        @selected = [HTML::Document.new(html).root]
        assert_select(*@expected, &block)
        return !@failed
      end

      def assert(val, msg=nil)
        unless !!val
          @msg = msg
          @failed = true
        end
      end

      def failure_message
        @msg
      end

      def failure_message_when_negated
        @msg
      end
    end

    def have_tag(*args)
      HaveTag.new(args)
    end
  end
end

require 'action_controller_test_process'
require File.expand_path(File.dirname(__FILE__) + '/mocha_rspec_adapter')
require File.expand_path(File.dirname(__FILE__) + '/mocha_extensions')
require File.expand_path(File.dirname(__FILE__) + '/ams_spec_helper')

require 'i18n_tasks'
require 'handlebars_tasks'

# if mocha was initialized before rails (say by another spec), CollectionProxy would have
# undef_method'd them; we need to restore them
Mocha::ObjectMethods.instance_methods.each do |m|
  ActiveRecord::Associations::CollectionProxy.class_eval <<-RUBY
    def #{m}; end
    remove_method #{m.inspect}
  RUBY
end

factories = "#{File.dirname(__FILE__).gsub(/\\/, "/")}/factories/*.rb"
Dir.glob(factories).each { |file| require file }

examples = "#{File.dirname(__FILE__).gsub(/\\/, "/")}/shared_examples/*.rb"
Dir.glob(examples).each { |file| require file }

def pend_with_bullet
  if defined?(Bullet) && Bullet.enable?
    skip ('PENDING: Bullet')
  end
end

def require_webmock
  # pull in webmock for selected tests, but leave it disabled by default.
  # funky require order is to skip typhoeus because of an incompatibility
  # see: https://github.com/typhoeus/typhoeus/issues/196
  require 'webmock/util/version_checker'
  require 'webmock/http_lib_adapters/http_lib_adapter_registry'
  require 'webmock/http_lib_adapters/http_lib_adapter'
  require 'webmock/http_lib_adapters/typhoeus_hydra_adapter'
  WebMock::HttpLibAdapterRegistry.instance.http_lib_adapters.delete :typhoeus
  require 'webmock/rspec'
end

# rspec aliases :describe to :context in a way that it's pretty much defined
# globally on every object. :context is already heavily used in our application,
# so we remove rspec's definition. This does not prevent 'context' from being
# used within a 'describe' block.

if defined?(Spec::DSL::Main)
  module Spec::DSL::Main
    remove_method :context if respond_to? :context
  end
end

def truncate_table(model)
  case model.connection.adapter_name
    when "SQLite"
      model.delete_all
      begin
        model.connection.execute("delete from sqlite_sequence where name='#{model.connection.quote_table_name(model.table_name)}';")
        model.connection.execute("insert into sqlite_sequence (name, seq) values ('#{model.connection.quote_table_name(model.table_name)}', #{rand(100)});")
      rescue
      end
    when "PostgreSQL"
      begin
        old_proc = model.connection.raw_connection.set_notice_processor {}
        model.connection.execute("TRUNCATE TABLE #{model.connection.quote_table_name(model.table_name)} CASCADE")
      ensure
        model.connection.raw_connection.set_notice_processor(&old_proc)
      end
    else
      model.connection.execute("SET FOREIGN_KEY_CHECKS=0")
      model.connection.execute("TRUNCATE TABLE #{model.connection.quote_table_name(model.table_name)}")
      model.connection.execute("SET FOREIGN_KEY_CHECKS=1")
  end
end

def truncate_all_tables
  model_connections = ActiveRecord::Base.descendants.map(&:connection).uniq
  model_connections.each do |connection|
    if connection.adapter_name == "PostgreSQL"
      # use custom SQL to exclude tables from extensions
      table_names = connection.query(<<-SQL, 'SCHEMA').map(&:first)
         SELECT tablename
         FROM pg_tables
         WHERE schemaname = ANY (current_schemas(false)) AND NOT tablename IN (
           SELECT CAST(objid::regclass AS VARCHAR) FROM pg_depend WHERE deptype='e'
         )
      SQL
      connection.execute("TRUNCATE TABLE #{table_names.map { |t| connection.quote_table_name(t) }.join(',')}")
    else
      connection.tables.each { |model| truncate_table(model) }
    end
  end
end

# wipe out the test db, in case some non-transactional tests crapped out before
# cleaning up after themselves
truncate_all_tables

# Make AR not puke if MySQL auto-commits the transaction
module MysqlOutsideTransaction
  def outside_transaction?
    # MySQL ignores creation of savepoints outside of a transaction; so if we can create one
    # and then can't release it because it doesn't exist, we're not in a transaction
    execute('SAVEPOINT outside_transaction')
    !!execute('RELEASE SAVEPOINT outside_transaction') rescue true
  end
end

module ActiveRecord::ConnectionAdapters
  if defined?(MysqlAdapter)
    MysqlAdapter.send(:include, MysqlOutsideTransaction)
  end
  if defined?(Mysql2Adapter)
    Mysql2Adapter.send(:include, MysqlOutsideTransaction)
  end
end

# Be sure to actually test serializing things to non-existent caches,
# but give Mocks a pass, since they won't exist in dev/prod
Mocha::Mock.class_eval do
  def marshal_dump
    nil
  end

  def marshal_load(data)
    raise "Mocks aren't really serializeable!"
  end

  def to_yaml(opts = {})
    YAML.quick_emit(self.object_id, opts) do |out|
      out.scalar(nil, 'null')
    end
  end

  def respond_to_with_marshalling?(symbol, include_private = false)
    return true if [:marshal_dump, :marshal_load].include?(symbol)
    respond_to_without_marshalling?(symbol, include_private)
  end

  alias_method_chain :respond_to?, :marshalling
end

RSpec::Matchers.define :encompass do |expected|
  match do |actual|
    if expected.is_a?(Array) && actual.is_a?(Array)
      expected.size == actual.size && expected.zip(actual).all? { |e, a| a.slice(*e.keys) == e }
    elsif expected.is_a?(Hash) && actual.is_a?(Hash)
      actual.slice(*expected.keys) == expected
    else
      false
    end
  end
end

RSpec::Matchers.define :match_ignoring_whitespace do |expected|
  def whitespaceless(str)
    str.gsub(/\s+/, '')
  end

  match do |actual|
    whitespaceless(actual) == whitespaceless(expected)
  end
end

module Helpers
  def message(opts={})
    m = Message.new
    m.to = opts[:to] || 'some_user'
    m.from = opts[:from] || 'some_other_user'
    m.subject = opts[:subject] || 'a message for you'
    m.body = opts[:body] || 'nice body'
    m.sent_at = opts[:sent_at] || 5.days.ago
    m.workflow_state = opts[:workflow_state] || 'sent'
    m.user_id = opts[:user_id] || opts[:user].try(:id)
    m.path_type = opts[:path_type] || 'email'
    m.root_account_id = opts[:account_id] || Account.default.id
    m.save!
    m
  end
end

# Make sure extensions will work with dynamically created shards
if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' &&
    ActiveRecord::Base.connection.schema_search_path == 'public'
  Canvas.possible_postgres_extensions.each do |extension|
    current_schema = ActiveRecord::Base.connection.select_value("SELECT nspname FROM pg_extension INNER JOIN pg_namespace ON extnamespace=pg_namespace.oid WHERE extname='#{extension}'")
    if current_schema && current_schema == 'public'
      ActiveRecord::Base.connection.execute("ALTER EXTENSION #{extension} SET SCHEMA pg_catalog") rescue nil
    end
  end
end

RSpec.configure do |config|
  # If you're not using ActiveRecord you should remove these
  # lines, delete config/database.yml and disable :active_record
  # in your config/boot.rb
  config.use_transactional_fixtures = true
  config.use_instantiated_fixtures = false
  config.fixture_path = Rails.root+'spec/fixtures/'
  config.infer_spec_type_from_file_location!

  config.include Helpers

  config.include Onceler::BasicHelpers

  # rspec 2+ only runs global before(:all)'s before the top-level
  # groups, not before each nested one. so we need to reset some
  # things to play nicely with its caching
  Onceler.configure do |c|
    c.before :record do
      Account.clear_special_account_cache!(true)
      Role.ensure_built_in_roles!
      AdheresToPolicy::Cache.clear
      Folder.reset_path_lookups!
    end
  end

  Onceler.instance_eval do
    # since once-ler creates potentially multiple levels of transaction
    # nesting, we need a way to know the base level so we can compare it
    # to AR::Conn#open_transactions. that will tell us if something is
    # "committed" or not (from the perspective of the spec)
    def base_transactions
      # if not recording, it's presumed we're in a spec, in which case
      # transactional fixtures add one more level
      open_transactions + (recording? ? 0 : 1)
    end
  end

  Notification.after_create do
    Notification.reset_cache!
    BroadcastPolicy.notification_finder.refresh_cache
  end

  config.before :all do
    # so before(:all)'s don't get confused
    Account.clear_special_account_cache!(true)
    Role.ensure_built_in_roles!
    AdheresToPolicy::Cache.clear
    # silence migration specs
    ActiveRecord::Migration.verbose = false
  end

  def delete_fixtures!
    # noop for now, needed for plugin spec tweaks. implementation coming
    # in g/24755
  end

  # UTC for tests, cuz it's easier :P
  Account.time_zone_attribute_defaults[:default_time_zone] = 'UTC'

  config.before :each do
    I18n.locale = :en
    Time.zone = 'UTC'
    LoadAccount.force_special_account_reload = true
    Account.clear_special_account_cache!(true)
    AdheresToPolicy::Cache.clear
    Setting.reset_cache!
    ConfigFile.unstub
    HostUrl.reset_cache!
    Notification.reset_cache!
    ActiveRecord::Base.reset_any_instantiation!
    Attachment.clear_cached_mime_ids
    Folder.reset_path_lookups!
    Role.ensure_built_in_roles!
    RoleOverride.clear_cached_contexts
    Delayed::Job.redis.flushdb if Delayed::Job == Delayed::Backend::Redis::Job
    Rails::logger.try(:info, "Running #{self.class.description} #{@method_name}")
    Attachment.domain_namespace = nil
    $spec_api_tokens = {}
  end

  # flush redis before the first spec, and before each spec that comes after
  # one that used redis
  class << Canvas
    attr_accessor :redis_used

    def redis_with_track_usage(*a, &b)
      self.redis_used = true
      redis_without_track_usage(*a, &b)
    end

    alias_method_chain :redis, :track_usage
    Canvas.redis_used = true
  end
  config.before :each do
    if Canvas.redis_enabled? && Canvas.redis_used
      Canvas.redis.flushdb
    end
    Canvas.redis_used = false
  end

  def account_with_cas(opts={})
    @account = opts[:account]
    @account ||= Account.create!
    config = AccountAuthorizationConfig::CAS.new
    cas_url = opts[:cas_url] || "https://localhost/cas"
    config.auth_type = "cas"
    config.auth_base = cas_url
    config.log_in_url = opts[:cas_log_in_url] if opts[:cas_log_in_url]
    @account.authentication_providers << config
    @account
  end

  def account_with_saml(opts={})
    @account = opts[:account]
    @account ||= Account.create!
    config = AccountAuthorizationConfig::SAML.new
    config.idp_entity_id = "saml_entity"
    config.auth_type = "saml"
    config.log_in_url = opts[:saml_log_in_url] if opts[:saml_log_in_url]
    config.log_out_url = opts[:saml_log_out_url] if opts[:saml_log_out_url]
    @account.authentication_providers << config
    @account
  end

  def course(opts={})
    account = opts[:account] || Account.default
    account.shard.activate do
      @course = Course.create!(:name => opts[:course_name], :account => account, :is_public => !!opts[:is_public])
      @course.offer! if opts[:active_course] || opts[:active_all]
      if opts[:active_all]
        u = User.create!
        u.register!
        e = @course.enroll_teacher(u)
        e.workflow_state = 'active'
        e.save!
        @teacher = u
      end
      if opts[:differentiated_assignments]
        account.allow_feature!(:differentiated_assignments)
        @course.enable_feature!(:differentiated_assignments)
      end
      create_grading_periods_for(@course, opts) if opts[:grading_periods]
    end
    @course
  end

  def create_grading_periods_for(context, opts={})
    opts = { mgp_flag_enabled: true }.merge(opts)
    context.root_account = Account.default if !context.root_account
    context.root_account.enable_feature!(:multiple_grading_periods) if opts[:mgp_flag_enabled]
    gp_group = context.grading_period_groups.create!
    class_name = context.class.name.demodulize
    timeframes = opts[:grading_periods] || [:current]
    now = Time.zone.now
    period_fixtures = {
      old: {
        start_date: 5.months.ago(now),
        end_date:   2.months.ago(now)
      },
      current: {
        start_date: 2.months.ago(now),
        end_date:   2.months.from_now(now)
      },
      future: {
        start_date: 2.months.from_now(now),
        end_date:   5.months.from_now(now)
      }
    }
    timeframes.map.with_index(1) do |timeframe, index|
      period_params = period_fixtures[timeframe].merge(title: "#{class_name} Period #{index}: #{timeframe} period")
      gp_group.grading_periods.create!(period_params)
    end
  end

  def account_with_role_changes(opts={})
    account = opts[:account] || Account.default
    if opts[:role_changes]
      opts[:role_changes].each_pair do |permission, enabled|
        role = opts[:role] || admin_role
        if ro = account.role_overrides.where(:permission => permission.to_s, :role_id => role.id).first
          ro.update_attribute(:enabled, enabled)
        else
          account.role_overrides.create(:permission => permission.to_s, :enabled => enabled, :role => role)
        end
      end
    end
    RoleOverride.clear_cached_contexts
  end

  def account_admin_user_with_role_changes(opts={})
    account_with_role_changes(opts)
    account_admin_user(opts)
  end

  def account_admin_user(opts={})
    opts = { active_user: true }.merge(opts)
    account = opts[:account] || Account.default
    create_grading_periods_for(account, opts) if opts[:grading_periods]
    @user = opts[:user] || account.shard.activate { user(opts) }
    @admin = @user

    account.account_users.create!(:user => @user, :role => opts[:role])
    @user
  end

  def site_admin_user(opts={})
    account_admin_user(opts.merge(account: Account.site_admin))
  end

  def user(opts={})
    @user = User.create!(opts.slice(:name, :short_name))
    if opts[:active_user] || opts[:active_all]
      @user.accept_terms
      @user.register!
    end
    @user.update_attribute :workflow_state, opts[:user_state] if opts[:user_state]
    @user
  end

  def user_with_pseudonym(opts={})
    user(opts) unless opts[:user]
    user = opts[:user] || @user
    @pseudonym = pseudonym(user, opts)
    user
  end

  def communication_channel(user, opts={})
    username = opts[:username] || "nobody@example.com"
    @cc = user.communication_channels.create!(:path_type => 'email', :path => username) do |cc|
      cc.workflow_state = 'active' if opts[:active_cc] || opts[:active_all]
      cc.workflow_state = opts[:cc_state] if opts[:cc_state]
    end
    @cc
  end

  def user_with_communication_channel(opts={})
    user(opts) unless opts[:user]
    user = opts[:user] || @user
    @cc = communication_channel(user, opts)
    user
  end

  def pseudonym(user, opts={})
    @spec_pseudonym_count ||= 0
    username = opts[:username] || (@spec_pseudonym_count > 0 ? "nobody+#{@spec_pseudonym_count}@example.com" : "nobody@example.com")
    opts[:username] ||= username
    @spec_pseudonym_count += 1 if username =~ /nobody(\+\d+)?@example.com/
    password = opts[:password] || "asdfasdf"
    password = nil if password == :autogenerate
    account = (opts[:account] ? opts[:account].root_account : Account.default)
    @pseudonym = account.pseudonyms.build(:user => user, :unique_id => username, :password => password, :password_confirmation => password)
    @pseudonym.save_without_session_maintenance
    @pseudonym.communication_channel = communication_channel(user, opts)
    @pseudonym
  end

  def managed_pseudonym(user, opts={})
    other_account = opts[:account] || account_with_saml
    if other_account.canvas_authentication?
      config = other_account.authentication_providers.build
      config.auth_type = "saml"
      config.log_in_url = opts[:saml_log_in_url] if opts[:saml_log_in_url]
      config.save!
    end
    opts[:account] = other_account
    pseudonym(user, opts)
    @pseudonym.sis_user_id = opts[:sis_user_id] || "U001"
    @pseudonym.save!
    @pseudonym
  end

  def user_with_managed_pseudonym(opts={})
    user(opts) unless opts[:user]
    user = opts[:user] || @user
    managed_pseudonym(user, opts)
    user
  end

  def course_with_user(enrollment_type, opts={})
    @course = opts[:course] || course(opts)
    @user = opts[:user] || @course.shard.activate { user(opts) }
    @enrollment = @course.enroll_user(@user, enrollment_type, opts)
    @user.save!
    @enrollment.course = @course # set the reverse association
    if opts[:active_enrollment] || opts[:active_all]
      @enrollment.workflow_state = 'active'
      @enrollment.save!
    end
    @course.reload
    @enrollment
  end

  def course_with_student(opts={})
    course_with_user('StudentEnrollment', opts)
    @student = @user
    @enrollment
  end

  def course_with_ta(opts={})
    course_with_user("TaEnrollment", opts)
    @ta = @user
    @enrollment
  end

  def course_with_student_logged_in(opts={})
    course_with_student(opts)
    user_session(@user)
  end

  def student_in_course(opts={})
    opts[:course] = @course if @course && !opts[:course]
    course_with_student(opts)
  end

  def student_in_section(section, opts={})
    student = opts.fetch(:user) { user }
    enrollment = section.course.enroll_user(student, 'StudentEnrollment', :section => section, :force_update => true)
    student.save!
    enrollment.workflow_state = 'active'
    enrollment.save!
    student
  end

  def ta_in_section(section, opts={})
    ta = opts.fetch(:user) { user }
    enrollment = section.course.enroll_user(ta, 'TaEnrollment', :section => section, :force_update => true)
    ta.save!
    enrollment.workflow_state = 'active'
    enrollment.save!
    ta
  end

  def teacher_in_course(opts={})
    opts[:course] = @course if @course && !opts[:course]
    course_with_teacher(opts)
  end

  def course_with_teacher(opts={})
    course_with_user('TeacherEnrollment', opts)
    @teacher = @user
    @enrollment
  end

  def course_with_designer(opts={})
    course_with_user('DesignerEnrollment', opts)
    @designer = @user
    @enrollment
  end

  def course_with_teacher_logged_in(opts={})
    course_with_teacher(opts)
    user_session(@user)
  end

  def course_with_observer(opts={})
    course_with_user('ObserverEnrollment', opts)
    @observer = @user
    @enrollment
  end

  def course_with_observer_logged_in(opts={})
    course_with_observer(opts)
    user_session(@user)
  end

  def course_with_student_submissions(opts={})
    course_with_teacher_logged_in(opts)
    student_in_course
    @course.claim! if opts[:unpublished]
    submission_count = opts[:submissions] || 1
    submission_count.times do |s|
      assignment = @course.assignments.create!(:title => "test #{s} assignment")
      submission = assignment.submissions.create!(:assignment_id => assignment.id, :user_id => @student.id)
      submission.update_attributes!(score: '5') if opts[:submission_points]
    end
  end

  def add_section(section_name)
    @course_section = @course.course_sections.create!(:name => section_name)
    @course.reload
  end

  def multiple_student_enrollment(user, section, opts={})
    course = opts[:course] || @course || course(opts)
    @enrollment = course.enroll_student(user,
                                         :enrollment_state => "active",
                                         :section => section,
                                         :allow_multiple_enrollments => true)
  end

  def enter_student_view(opts={})
    course = opts[:course] || @course || course(opts)
    @fake_student = course.student_view_student
    post "/users/#{@fake_student.id}/masquerade"
    expect(session[:become_user_id]).to eq @fake_student.id.to_s
  end

  def account_notification(opts={})
    req_service = opts[:required_account_service] || nil
    role_ids = opts[:role_ids] || []
    message = opts[:message] || "hi there"
    subj = opts[:subject] || "this is a subject"
    @account = opts[:account] || Account.default
    @announcement = @account.announcements.build(subject: subj, message: message, required_account_service: req_service)
    @announcement.start_at = opts[:start_at] || 5.minutes.ago.utc
    @announcement.end_at = opts[:end_at] || 1.day.from_now.utc
    @announcement.account_notification_roles.build(role_ids.map { |r_id| {account_notification_id: @announcement.id, role: Role.get_role_by_id(r_id)} }) unless role_ids.empty?
    @announcement.save!
    @announcement
  end

  VALID_GROUP_ATTRIBUTES = [:name, :context, :max_membership, :group_category, :join_level, :description, :is_public, :avatar_attachment]

  def group(opts={})
    context = opts[:group_context] || opts[:context] || Account.default
    @group = context.groups.create! opts.slice(*VALID_GROUP_ATTRIBUTES)
  end

  def group_with_user(opts={})
    group(opts)
    u = opts[:user] || user(opts)
    workflow_state = opts[:active_all] ? 'accepted' : nil
    @group.add_user(u, workflow_state, opts[:moderator])
  end

  def group_with_user_logged_in(opts={})
    group_with_user(opts)
    user_session(@user)
  end

  def group_category(opts = {})
    context = opts[:context] || @course
    @group_category = context.group_categories.create!(name: opts[:name] || 'foo')
  end

  def custom_role(base, name, opts={})
    account = opts[:account] || @account
    role = account.roles.where(name: name).first_or_initialize
    role.base_role_type = base
    role.save!
    role
  end

  def custom_student_role(name, opts={})
    custom_role('StudentEnrollment', name, opts)
  end

  def custom_teacher_role(name, opts={})
    custom_role('TeacherEnrollment', name, opts)
  end

  def custom_ta_role(name, opts={})
    custom_role('TaEnrollment', name, opts)
  end

  def custom_designer_role(name, opts={})
    custom_role('DesignerEnrollment', name, opts)
  end

  def custom_observer_role(name, opts={})
    custom_role('ObserverEnrollment', name, opts)
  end

  def custom_account_role(name, opts={})
    custom_role(Role::DEFAULT_ACCOUNT_TYPE, name, opts)
  end

  def student_role
    Role.get_built_in_role("StudentEnrollment")
  end

  def teacher_role
    Role.get_built_in_role("TeacherEnrollment")
  end

  def ta_role
    Role.get_built_in_role("TaEnrollment")
  end

  def designer_role
    Role.get_built_in_role("DesignerEnrollment")
  end

  def observer_role
    Role.get_built_in_role("ObserverEnrollment")
  end

  def admin_role
    Role.get_built_in_role("AccountAdmin")
  end

  def user_session(user, pseudonym=nil)
    unless pseudonym
      pseudonym = stub('Pseudonym', :record => user, :user_id => user.id, :user => user, :login_count => 1)
      # at least one thing cares about the id of the pseudonym... using the
      # object_id should make it unique (but obviously things will fail if
      # it tries to load it from the db.)
      pseudonym.stubs(:id).returns(pseudonym.object_id)
      pseudonym.stubs(:unique_id).returns('unique_id')
    end

    session = stub('PseudonymSession', :record => pseudonym, :session_credentials => nil)

    PseudonymSession.stubs(:find).returns(session)
  end

  def remove_user_session
    PseudonymSession.unstub(:find)
  end

  def login_as(username = "nobody@example.com", password = "asdfasdf")
    post_via_redirect "/login",
                      "pseudonym_session[unique_id]" => username,
                      "pseudonym_session[password]" => password
    assert_response :success
    expect(request.fullpath).to eq "/?login_success=1"
  end

  def assignment_quiz(questions, opts={})
    course = opts[:course] || course(:active_course => true)
    user = opts[:user] || user(:active_user => true)
    course.enroll_student(user, :enrollment_state => 'active') unless user.enrollments.any? { |e| e.course_id == course.id }
    @assignment = course.assignments.create(:title => "Test Assignment")
    @assignment.workflow_state = "published"
    @assignment.submission_types = "online_quiz"
    @assignment.save
    @quiz = Quizzes::Quiz.where(assignment_id: @assignment).first
    @questions = questions.map { |q| @quiz.quiz_questions.create!(q) }
    @quiz.generate_quiz_data
    @quiz.published_at = Time.now
    @quiz.workflow_state = "available"
    @quiz.save!
  end

  # The block should return the submission_data. A block is used so
  # that we have access to the @questions variable that is created
  # in this method
  def quiz_with_graded_submission(questions, opts={}, &block)
    assignment_quiz(questions, opts)
    @quiz_submission = @quiz.generate_submission(@user)
    @quiz_submission.mark_completed
    @quiz_submission.submission_data = yield if block_given?
    Quizzes::SubmissionGrader.new(@quiz_submission).grade_submission
  end

  def survey_with_submission(questions, &block)
    course_with_student(:active_all => true)
    @assignment = @course.assignments.create(:title => "Test Assignment")
    @assignment.workflow_state = "published"
    @assignment.submission_types = "online_quiz"
    @assignment.save
    @quiz = Quizzes::Quiz.where(assignment_id: @assignment).first
    @quiz.anonymous_submissions = true
    @quiz.quiz_type = "graded_survey"
    @questions = questions.map { |q| @quiz.quiz_questions.create!(q) }
    @quiz.generate_quiz_data
    @quiz.save!
    @quiz_submission = @quiz.generate_submission(@user)
    @quiz_submission.mark_completed
    @quiz_submission.submission_data = yield if block_given?
  end

  def group_discussion_assignment
    course = @course || course(:active_all => true)
    group_category = course.group_categories.create!(:name => "category")
    @group1 = course.groups.create!(:name => "group 1", :group_category => group_category)
    @group2 = course.groups.create!(:name => "group 2", :group_category => group_category)

    @topic = course.discussion_topics.build(:title => "topic")
    @topic.group_category = group_category
    @assignment = course.assignments.build(:submission_types => 'discussion_topic', :title => @topic.title)
    @assignment.infer_times
    @assignment.saved_by = :discussion_topic
    @topic.assignment = @assignment
    @topic.save!
  end

  def rubric_for_course
    @rubric = Rubric.new(:title => 'My Rubric', :context => @course)
    @rubric.data = [
        {
            :points => 3,
            :description => "First row",
            :long_description => "The first row in the rubric",
            :id => 1,
            :ratings => [
                {
                    :points => 3,
                    :description => "Rockin'",
                    :criterion_id => 1,
                    :id => 2
                },
                {
                    :points => 2,
                    :description => "Rockin'",
                    :criterion_id => 1,
                    :id => 3
                },
                {
                    :points => 0,
                    :description => "Lame",
                    :criterion_id => 1,
                    :id => 4
                }
            ]
        }
    ]
    @rubric.save!
  end

  def outcome_with_rubric(opts={})
    @outcome_group ||= @course.root_outcome_group
    @outcome = @course.created_learning_outcomes.create!(
      :description => '<p>This is <b>awesome</b>.</p>',
      :short_description => 'new outcome',
      :calculation_method => 'highest'
    )
    @outcome_group.add_outcome(@outcome)
    @outcome_group.save!

    rubric_params = {
        :title => 'My Rubric',
        :hide_score_total => false,
        :criteria => {
            "0" => {
                :points => 3,
                :mastery_points => opts[:mastery_points] || 0,
                :description => "Outcome row",
                :long_description => @outcome.description,
                :ratings => {
                    "0" => {
                        :points => 3,
                        :description => "Rockin'",
                    },
                    "1" => {
                        :points => 0,
                        :description => "Lame",
                    }
                },
                :learning_outcome_id => @outcome.id
            },
            "1" => {
                :points => 5,
                :description => "no outcome row",
                :long_description => 'non outcome criterion',
                :ratings => {
                    "0" => {
                        :points => 5,
                        :description => "Amazing",
                    },
                    "1" => {
                        :points => 3,
                        :description => "not too bad",
                    },
                    "2" => {
                        :points => 0,
                        :description => "no bueno",
                    }
                }
            }
        }
    }

    @rubric = @course.rubrics.build
    @rubric.update_criteria(rubric_params)
    @rubric.reload
  end

  def grading_standard_for(context, opts={})
    @standard = context.grading_standards.create!(
        :title => opts[:title] || "My Grading Standard",
        :standard_data => {
            "scheme_0" => {:name => "A", :value => "0.9"},
            "scheme_1" => {:name => "B", :value => "0.8"},
            "scheme_2" => {:name => "C", :value => "0.7"}
        })
  end

  def eportfolio(opts={})
    user(opts) unless @user
    @portfolio = @user.eportfolios.create!
  end

  def eportfolio_with_user(opts={})
    user(opts)
    eportfolio(opts)
  end

  def conversation(*users)
    options = users.last.is_a?(Hash) ? users.pop : {}
    @conversation = (options.delete(:sender) || @me || users.shift).initiate_conversation(users, options.delete(:private))

    # if the "body" hash is passed in, use that for the message body
    if !options[:body].nil?
      @message = @conversation.add_message(options[:body].to_s)
    else
      @message = @conversation.add_message('test')
    end

    @conversation.update_attributes(options)
    @conversation.reload
  end

  def media_object(opts={})
    mo = MediaObject.new
    mo.media_id = opts[:media_id] || "1234"
    mo.media_type = opts[:media_type] || "video"
    mo.context = opts[:context] || @course
    mo.user = opts[:user] || @user
    mo.save!
    mo
  end

  def assert_status(status=500)
    expect(response.status.to_i).to eq status
  end

  def assert_unauthorized
    # we allow either a raw unauthorized or a redirect to login
    unless response.status == 401
       expect(response).to redirect_to(login_url)
    end
  end

  def assert_page_not_found
    yield
    assert_status(404)
  end

  def assert_require_login
    expect(response).to be_redirect
    expect(flash[:warning]).to eq "You must be logged in to access this page"
  end

  def fixture_file_upload(path, mime_type=nil, binary=false)
    Rack::Test::UploadedFile.new(File.join(ActionController::TestCase.fixture_path, path), mime_type, binary)
  end

  def default_uploaded_data
    fixture_file_upload('scribd_docs/doc.doc', 'application/msword', true)
  end

  def valid_gradebook_csv_content
    File.read(File.expand_path(File.join(File.dirname(__FILE__), %w(fixtures default_gradebook.csv))))
  end

  def factory_with_protected_attributes(ar_klass, attrs, do_save = true)
    obj = ar_klass.respond_to?(:new) ? ar_klass.new : ar_klass.build
    attrs.each { |k, v| obj.send("#{k}=", attrs[k]) }
    obj.save! if do_save
    obj
  end

  def update_with_protected_attributes!(ar_instance, attrs)
    attrs.each { |k, v| ar_instance.send("#{k}=", attrs[k]) }
    ar_instance.save!
  end

  def update_with_protected_attributes(ar_instance, attrs)
    update_with_protected_attributes!(ar_instance, attrs) rescue false
  end

  def process_csv_data(*lines)
    opts = lines.extract_options!
    opts.reverse_merge!(allow_printing: false)
    account = opts[:account] || @account || account_model

    tmp = Tempfile.new("sis_rspec")
    path = "#{tmp.path}.csv"
    tmp.close!
    File.open(path, "w+") { |f| f.puts lines.flatten.join "\n" }
    opts[:files] = [path]

    importer = SIS::CSV::Import.process(account, opts)

    File.unlink path

    importer
  end

  def process_csv_data_cleanly(*lines_or_opts)
    importer = process_csv_data(*lines_or_opts)
    expect(importer.errors).to eq []
    expect(importer.warnings).to eq []
  end

  def enable_cache(new_cache=:memory_store)
    new_cache ||= :null_store
    new_cache = ActiveSupport::Cache.lookup_store(new_cache)
    previous_cache = Rails.cache
    Rails.stubs(:cache).returns(new_cache)
    ActionController::Base.stubs(:cache_store).returns(new_cache)
    ActionController::Base.any_instance.stubs(:cache_store).returns(new_cache)
    previous_perform_caching = ActionController::Base.perform_caching
    ActionController::Base.stubs(:perform_caching).returns(true)
    ActionController::Base.any_instance.stubs(:perform_caching).returns(true)
    if block_given?
      begin
        yield
      ensure
        Rails.stubs(:cache).returns(previous_cache)
        ActionController::Base.stubs(:cache_store).returns(previous_cache)
        ActionController::Base.any_instance.stubs(:cache_store).returns(previous_cache)
        ActionController::Base.stubs(:perform_caching).returns(previous_perform_caching)
        ActionController::Base.any_instance.stubs(:perform_caching).returns(previous_perform_caching)
      end
    end
  end

  # enforce forgery protection, so we can verify usage of the authenticity token
  def enable_forgery_protection(enable = true)
    old_value = ActionController::Base.allow_forgery_protection
    ActionController::Base.stubs(:allow_forgery_protection).returns(enable)
    ActionController::Base.any_instance.stubs(:allow_forgery_protection).returns(enable)

    yield if block_given?

  ensure
    if block_given?
      ActionController::Base.stubs(:allow_forgery_protection).returns(old_value)
      ActionController::Base.any_instance.stubs(:allow_forgery_protection).returns(old_value)
    end
  end

  def stub_kaltura
    # trick kaltura into being activated
    CanvasKaltura::ClientV3.stubs(:config).returns({
                                                 'domain' => 'kaltura.example.com',
                                                 'resource_domain' => 'kaltura.example.com',
                                                 'partner_id' => '100',
                                                 'subpartner_id' => '10000',
                                                 'secret_key' => 'fenwl1n23k4123lk4hl321jh4kl321j4kl32j14kl321',
                                                 'user_secret_key' => '1234821hrj3k21hjk4j3kl21j4kl321j4kl3j21kl4j3k2l1',
                                                 'player_ui_conf' => '1',
                                                 'kcw_ui_conf' => '1',
                                                 'upload_ui_conf' => '1'
                                             })
  end

  def attachment_obj_with_context(obj, opts={})
    @attachment = factory_with_protected_attributes(Attachment, valid_attachment_attributes.merge(opts))
    @attachment.context = obj
    @attachment
  end

  def attachment_with_context(obj, opts={})
    attachment_obj_with_context(obj, opts)
    @attachment.save!
    @attachment
  end

  def json_parse(json_string = response.body)
    JSON.parse(json_string.sub(%r{^while\(1\);}, ''))
  end

  # inspired by http://blog.jayfields.com/2007/08/ruby-calling-methods-of-specific.html
  module AttachmentStorageSwitcher
    BACKENDS = %w{FileSystem S3}.map { |backend| AttachmentFu::Backends.const_get(:"#{backend}Backend") }.freeze

    class As #:nodoc:
      private *instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ }

      def initialize(subject, ancestor)
        @subject = subject
        @ancestor = ancestor
      end

      def method_missing(sym, *args, &blk)
        @ancestor.instance_method(sym).bind(@subject).call(*args, &blk)
      end
    end

    def self.included(base)
      base.cattr_accessor :current_backend
      base.current_backend = (base.ancestors & BACKENDS).first

      # make sure we have all the backends
      BACKENDS.each do |backend|
        base.send(:include, backend) unless base.ancestors.include?(backend)
      end
      # remove the duplicate callbacks added by multiple backends
      base.before_update.uniq!

      BACKENDS.map(&:instance_methods).flatten.uniq.each do |method|
        # overridden by Attachment anyway; don't re-overwrite it
        next if base.instance_method(method).owner == base
        if method.to_s[-1..-1] == '='
          base.class_eval <<-CODE
          def #{method}(arg)
            self.as(self.class.current_backend).#{method} arg
          end
          CODE
        else
          base.class_eval <<-CODE
          def #{method}(*args, &block)
            self.as(self.class.current_backend).#{method}(*args, &block)
          end
          CODE
        end
      end
    end

    def as(ancestor)
      @__as ||= {}
      unless r = @__as[ancestor]
        r = (@__as[ancestor] = As.new(self, ancestor))
      end
      r
    end
  end

  def s3_storage!(opts = {:stubs => true})
    [Attachment, Thumbnail].each do |model|
      model.send(:include, AttachmentStorageSwitcher) unless model.ancestors.include?(AttachmentStorageSwitcher)
      model.stubs(:current_backend).returns(AttachmentFu::Backends::S3Backend)

      model.stubs(:s3_storage?).returns(true)
      model.stubs(:local_storage?).returns(false)
    end

    if opts[:stubs]
      conn = mock('AWS::S3::Client')

      AWS::S3::S3Object.any_instance.stubs(:read).returns("i am stub data from spec helper. nom nom nom")
      AWS::S3::S3Object.any_instance.stubs(:write).returns(true)
      AWS::S3::S3Object.any_instance.stubs(:create_temp_file).returns(true)
      AWS::S3::S3Object.any_instance.stubs(:client).returns(conn)
      AWS::Core::Configuration.any_instance.stubs(:access_key_id).returns('stub_id')
      AWS::Core::Configuration.any_instance.stubs(:secret_access_key).returns('stub_key')
      AWS::S3::Bucket.any_instance.stubs(:name).returns('no-bucket')
    else
      if Attachment.s3_config.blank? || Attachment.s3_config[:access_key_id] == 'access_key'
        skip "Please put valid S3 credentials in config/amazon_s3.yml"
      end
    end
    expect(Attachment.s3_storage?).to be true
    expect(Attachment.local_storage?).to be false
  end

  def local_storage!
    [Attachment, Thumbnail].each do |model|
      model.send(:include, AttachmentStorageSwitcher) unless model.ancestors.include?(AttachmentStorageSwitcher)
      model.stubs(:current_backend).returns(AttachmentFu::Backends::FileSystemBackend)

      model.stubs(:s3_storage?).returns(false)
      model.stubs(:local_storage?).returns(true)
    end

    expect(Attachment.local_storage?).to be true
    expect(Attachment.s3_storage?).to be false
  end

  def run_job(job)
    Delayed::Worker.new.perform(job)
  end

  def run_jobs
    while job = Delayed::Job.get_and_lock_next_available(
        'spec run_jobs',
        Delayed::Settings.queue,
        0,
        Delayed::MAX_PRIORITY)
      run_job(job)
    end
  end

  def track_jobs
    @jobs_tracking = Delayed::JobTracking.track { yield }
  end

  def created_jobs
    @jobs_tracking.created
  end

  def expects_job_with_tag(tag, count = 1)
    track_jobs do
      yield
    end
    expect(created_jobs.count { |j| j.tag == tag }).to eq count
  end

  # send a multipart post request in an integration spec post_params is
  # an array of [k,v] params so that the order of the params can be
  # defined
  def send_multipart(url, post_params = {}, http_headers = {}, method = :post)
    mp = Multipart::Post.new
    query, headers = mp.prepare_query(post_params)

    # A bug in the testing adapter in Rails 3-2-stable doesn't corretly handle
    # translating this header to the Rack/CGI compatible version:
    # (https://github.com/rails/rails/blob/3-2-stable/actionpack/lib/action_dispatch/testing/integration.rb#L289)
    #
    # This issue is fixed in Rails 4-0 stable, by using a newer version of
    # ActionDispatch Http::Headers which correctly handles the merge
    headers = headers.dup.tap { |h| h['CONTENT_TYPE'] ||= h.delete('Content-type') }

    send(method, url, query, headers.merge(http_headers))
  end

  def force_string_encoding(str, encoding = "UTF-8")
    if str.respond_to?(:force_encoding)
      str.force_encoding(encoding)
    end
    str
  end

  # from minitest, MIT licensed
  def capture_io
    orig_stdout, orig_stderr = $stdout, $stderr
    $stdout, $stderr = StringIO.new, StringIO.new
    yield
    return $stdout.string, $stderr.string
  ensure
    $stdout, $stderr = orig_stdout, orig_stderr
  end

  def verify_post_matches(post_lines, expected_post_lines)
    # first lines should match
    expect(post_lines[0]).to eq expected_post_lines[0]

    # now extract the headers
    post_headers = post_lines[1..post_lines.index("")]
    expected_post_headers = expected_post_lines[1..expected_post_lines.index("")]
    expected_post_headers << "User-Agent: Ruby"
    expect(post_headers.sort).to eq expected_post_headers.sort

    # now check payload
    expect(post_lines[post_lines.index(""), -1]).to eq
        expected_post_lines[expected_post_lines.index(""), -1]
  end

  def compare_json(actual, expected)
    if actual.is_a?(Hash)
      actual.each do |k, v|
        expected_v = expected[k]
        compare_json(v, expected_v)
      end
    elsif actual.is_a?(Array)
      actual.zip(expected).each do |a, e|
        compare_json(a, e)
      end
    else
      if actual.is_a?(Fixnum) || actual.is_a?(Float)
        expect(actual).to eq expected
      else
        expect(actual.to_json).to eq expected.to_json
      end
    end
  end

  class FakeHttpResponse
    def initialize(code, body = nil, headers={})
      @code = code
      @body = body
      @headers = headers
    end

    def read_body(io)
      io << @body
    end

    def code
      @code.to_s
    end

    def [](arg)
      @headers[arg]
    end

    def content_type
      self['content-type']
    end
  end

  def intify_timestamps(object)
    case object
      when Time
        object.to_i
      when Hash
        object.inject({}) { |memo, (k, v)| memo[intify_timestamps(k)] = intify_timestamps(v); memo }
      when Array
        object.map { |v| intify_timestamps(v) }
      else
        object
    end
  end

  # frd class, not a mock, so we can once-ler WebConferences (need to Marshal.dump)
  class WebConferencePluginMock
    attr_reader :id, :settings
    def initialize(id, settings)
      @id = id
      @settings = settings
    end

    def valid_settings?; true; end

    def enabled?; true; end

    def base; end
  end
  def web_conference_plugin_mock(id, settings)
    WebConferencePluginMock.new(id, settings)
  end

  def dummy_io
    fixture_file_upload('scribd_docs/doc.doc', 'application/msword', true)
  end

  def create_attachment_for_file_upload_submission!(submission, opts={})
    submission.attachments.create! opts.merge(
                                       :filename => "doc.doc",
                                       :display_name => "doc.doc", :user => @user,
                                       :uploaded_data => dummy_io)
  end

  def course_quiz(active=false)
    @quiz = @course.quizzes.create
    @quiz.workflow_state = "available" if active
    @quiz.save!
    @quiz
  end

  def n_students_in_course(n, opts={})
    opts.reverse_merge active_all: true
    n.times.map { student_in_course(opts); @student }
  end

  def consider_all_requests_local(value)
    Rails.application.config.consider_all_requests_local = value
  end

  def page_view_for(opts={})
    @account = opts[:account] || Account.default
    @context = opts[:context] || course(opts)

    @request_id = opts[:request_id] || RequestContextGenerator.request_id
    unless @request_id
      @request_id = SecureRandom.uuid
      RequestContextGenerator.stubs(:request_id => @request_id)
    end

    Setting.set('enable_page_views', 'db')

    @page_view = PageView.new { |p|
      p.assign_attributes({
                              :id => @request_id,
                              :url => "http://test.one/",
                              :session_id => "phony",
                              :context => @context,
                              :controller => opts[:controller] || 'courses',
                              :action => opts[:action] || 'show',
                              :user_request => true,
                              :render_time => 0.01,
                              :user_agent => 'None',
                              :account_id => @account.id,
                              :request_id => request_id,
                              :interaction_seconds => 5,
                              :user => @user,
                              :remote_ip => '192.168.0.42'
                          }, :without_protection => true)
    }
    @page_view.save!
    @page_view
  end

  # a fast way to create a record, especially if you don't need the actual
  # ruby object. since it just does a straight up insert, you need to
  # provide any non-null attributes or things that would normally be
  # inferred/defaulted prior to saving
  def create_record(klass, attributes, return_type = :id)
    create_records(klass, [attributes], return_type)[0]
  end

  # a little wrapper around bulk_insert that gives you back records or ids
  # in order
  # NOTE: if you decide you want to go add something like this to canvas
  # proper, make sure you have it handle concurrent inserts (this does
  # not, because READ COMMITTED is the default transaction isolation
  # level)
  def create_records(klass, records, return_type = :id)
    return [] if records.empty?
    klass.transaction do
      klass.connection.bulk_insert klass.table_name, records
      scope = klass.order("id DESC").limit(records.size)
      return_type == :record ?
        scope.all.reverse :
        scope.pluck(:id).reverse
    end
  end

  # create a bunch of courses at once, optionally enrolling a user in them
  # records can either be the number of records to create, or an array of
  # hashes of attributes you want to insert
  def create_courses(records, options = {})
    account = options[:account] || Account.default
    records = records.times.map{ {} } if records.is_a?(Fixnum)
    records = records.map { |record| course_valid_attributes.merge(account_id: account.id, root_account_id: account.id, workflow_state: 'available', enrollment_term_id: account.default_enrollment_term.id).merge(record) }
    course_data = create_records(Course, records, options[:return_type])
    course_ids = options[:return_type] == :record ?
      course_data.map(&:id) :
      course_data

    if options[:account_associations]
      create_records(CourseAccountAssociation, course_ids.map{ |id| {account_id: account.id, course_id: id, depth: 0}})
    end
    if user = options[:enroll_user]
      section_ids = create_records(CourseSection, course_ids.map{ |id| {course_id: id, root_account_id: account.id, name: "Default Section", default_section: true}})
      type = options[:enrollment_type] || "TeacherEnrollment"
      create_records(Enrollment, course_ids.each_with_index.map{ |id, i| {course_id: id, user_id: user.id, type: type, course_section_id: section_ids[i], root_account_id: account.id, workflow_state: 'active', :role_id => Role.get_built_in_role(type).id}})
    end
    course_data
  end

  def create_users(records, options = {})
    records = records.times.map{ {} } if records.is_a?(Fixnum)
    records = records.map { |record| valid_user_attributes.merge(workflow_state: "registered").merge(record) }
    create_records(User, records, options[:return_type])
  end

  # create a bunch of users at once, and enroll them all in the same course
  def create_users_in_course(course, records, options = {})
    user_data = create_users(records, options)
    create_enrollments(course, user_data, options)

    user_data
  end

  def create_enrollments(course, users, options = {})
    user_ids = users.first.is_a?(User) ?
      users.map(&:id) :
      users

    if options[:account_associations]
      create_records(UserAccountAssociation, user_ids.map{ |id| {account_id: course.account_id, user_id: id, depth: 0}})
    end

    section_id = options[:section_id] || course.default_section.id
    type = options[:enrollment_type] || "StudentEnrollment"
    create_records(Enrollment, user_ids.map{ |id| {course_id: course.id, user_id: id, type: type, course_section_id: section_id, root_account_id: course.account.id, workflow_state: 'active', :role_id => Role.get_built_in_role(type).id}}, options[:return_type])
  end

  def create_assignments(course_ids, count_per_course = 1, fields = {})
    course_ids = Array(course_ids)
    course_ids *= count_per_course
    create_records(Assignment, course_ids.each_with_index.map { |id, i| {context_id: id, context_type: 'Course', context_code: "course_#{id}", title: "#{id}:#{i}", grading_type: "points", submission_types: "none", workflow_state: 'published'}.merge(fields)})
  end
end

class I18nema::Backend
  def stub(translations)
    @stubs = translations.with_indifferent_access
    singleton_class.instance_eval do
      alias_method :lookup, :lookup_with_stubs
      alias_method :available_locales, :available_locales_with_stubs
    end
    yield
  ensure
    singleton_class.instance_eval do
      alias_method :lookup, :lookup_without_stubs
      alias_method :available_locales, :available_locales_without_stubs
    end
    @stubs = nil
  end

  def lookup_with_stubs(locale, key, scope = [], options = {})
    init_translations unless initialized?
    keys = normalize_keys(locale, key, scope, options[:separator])
    keys.inject(@stubs){ |h,k| h[k] if h.respond_to?(:key) } || direct_lookup(*keys)
  end
  alias_method :lookup_without_stubs, :lookup

  def available_locales_with_stubs
    available_locales_without_stubs | @stubs.keys.map(&:to_sym)
  end
  alias_method :available_locales_without_stubs, :available_locales
end

class String
  def red; colorize(self, "\e[1m\e[31m"); end

  def green; colorize(self, "\e[1m\e[32m"); end

  def dark_green; colorize(self, "\e[32m"); end

  def yellow; colorize(self, "\e[1m\e[33m"); end

  def blue; colorize(self, "\e[1m\e[34m"); end

  def dark_blue; colorize(self, "\e[34m"); end

  def pur; colorize(self, "\e[1m\e[35m"); end

  def colorize(text, color_code)  "#{color_code}#{text}\e[0m" end
end

Dir[Rails.root+'{gems,vendor}/plugins/*/spec_canvas/spec_helper.rb'].each do |f|
  require f
end