materials_controller_test.rb

require 'test_helper'

class MaterialsControllerTest < ActionController::TestCase
  include Devise::Test::ControllerHelpers
  include ActiveJob::TestHelper

  setup do
    mock_images
    mock_biotools
    @material = materials(:good_material)
    @event = events(:one)
    @collection = collections(:two)
    @user = users(:regular_user)
    @material.user_id = @user.id
    @material.save!
    @updated_material = {
      title: 'New title',
      description: 'New description',
      url: 'http://new.url.com',
      content_provider_id: ContentProvider.first.id
    }
    @failing_material = materials(:failing_material)
    @failing_material.title = 'Fail!'
    @monitor = @failing_material.create_link_monitor(url: @failing_material.url, code: 404, fail_count: 5)
  end

  # Tests
  # INDEX, NEW, EDIT, CREATE, SHOW, BREADCRUMBS, TABS, API CHECKS

  # INDEX TESTS
  test 'should get index' do
    get :index
    assert_response :success
    assert_select '#content h2', text: 'Training materials'
    assert_not_nil assigns(:materials)
  end

  test 'should get index with solr enabled' do
    with_settings(solr_enabled: true) do
      Material.stub(:search_and_filter, MockSearch.new(Material.all)) do
        get :index, params: { q: 'breakdance for beginners', keywords: 'dancing' }
        assert_response :success
        assert_not_empty assigns(:materials)
        assert_select '.searchbox-sm form[action=?]', materials_path
      end
    end
  end

  test 'should get index as json' do
    @material.scientific_topic_uris = ['http://edamontology.org/topic_0654']
    @material.save!

    get :index, params: { format: :json }
    assert_response :success
    assert_not_nil assigns(:materials)
    assert_valid_legacy_json_response
    assert_nothing_raised do
      JSON.parse(response.body)
    end
  end

  test 'should get index as json-api' do
    @material.scientific_topic_uris = ['http://edamontology.org/topic_0654']
    @material.save!

    get :index, params: { format: :json_api }
    assert_response :success
    assert_not_nil assigns(:materials)
    assert_valid_json_api_response
    body = nil
    assert_nothing_raised do
      body = JSON.parse(response.body)
    end

    assert body['data'].any?
    assert body['meta']['results-count'] > 0
    assert body['meta'].key?('query')
    assert body['meta'].key?('facets')
    assert body['meta'].key?('available-facets')
    assert_equal materials_path, body['links']['self']
  end

  test 'should get faceted index as json-api with search enabled' do
    @material.scientific_topic_uris = ['http://edamontology.org/topic_0654']
    @material.save!

    with_settings(solr_enabled: true) do
      Material.stub(:search_and_filter, MockSearch.new(Material.all)) do
        get :index, params: { q: 'breakdance for beginners', keywords: 'dancing', format: :json_api }
        assert_response :success
        assert_not_nil assigns(:materials)
        assert_valid_json_api_response
        body = nil
        assert_nothing_raised do
          body = JSON.parse(response.body)
        end

        assert body['data'].any?
        assert body['meta']['results-count'] > 0
        assert_equal 'breakdance for beginners', body['meta']['query']
        assert_includes body['meta']['facets']['keywords'], 'dancing'
        assert body['meta']['available-facets'].keys.any?
        assert body['meta']['available-facets'].values.any?
        assert body['links']['self'].include?('dancing')
        assert body['links']['self'].include?('breakdance+for+beginners')
      end
    end
  end

  test 'admins should be able to directly load failing records' do
    sign_in users(:admin)
    get :show, params: { id: @failing_material }
    assert_response :success
  end

  test 'regular users should be able to directly load failing record and see warning' do
    sign_in users(:regular_user)
    @monitor.update(failed_at: DateTime.new(2023, 4, 2))
    get :show, params: { id: @failing_material }
    assert_response :success
    assert_select '.broken-link-notice', text: /this material's URL.+since 2 April 2023/
  end

  # NEW TESTS
  test 'should get new' do
    sign_in users(:regular_user)
    get :new
    assert_response :success
  end

  test 'should get new page for logged in users only' do
    # Redirect to login if not logged in
    get :new
    assert_response :redirect
    sign_in users(:regular_user)
    # Success for everyone else
    get :new
    assert_response :success
    sign_in users(:admin)
    get :new
    assert_response :success
  end

  test 'should not get new page for basic users' do
    sign_in users(:basic_user)
    get :new
    assert_response :forbidden
  end

  # EDIT TESTS
  test 'should not get edit page for not logged in users' do
    # Not logged in = Redirect to login
    get :edit, params: { id: @material }
    assert_redirected_to new_user_session_path
  end

  # logged in but insufficient permissions = ERROR
  test 'should get edit for material owner' do
    sign_in users(:regular_user)
    get :edit, params: { id: @material }
    assert_response :success
  end

  test 'should get edit for admin' do
    # Owner of material logged in = SUCCESS
    sign_in users(:admin)
    get :edit, params: { id: @material }
    assert_response :success
  end

  test 'should get edit for curator' do
    sign_in users(:curator)
    get :edit, params: { id: @material }
    assert_response :success
  end

  test 'should get edit for content provider owner' do
    sign_in users(:curator)
    get :edit, params: { id: materials(:scraper_user_material) }
    assert_response :success
  end

  test 'should not get edit page for non-owner user' do
    # Administrator = SUCCESS
    sign_in users(:another_regular_user)
    get :edit, params: { id: @material }
    assert :forbidden
  end

  test 'should get edit page for approved editor' do
    @material.content_provider.add_editor users(:another_regular_user)
    sign_in users(:another_regular_user)
    get :edit, params: { id: @material }
    assert_response :success
  end

  # CREATE TEST
  test 'should create material for user' do
    sign_in users(:regular_user)
    assert_difference('Material.count') do
      post :create, params: {
        material: {
          doi: @material.doi,
          remote_created_date: @material.remote_created_date,
          remote_updated_date: @material.remote_updated_date,
          description: @material.description,
          title: @material.title,
          url: @material.url,
          licence: @material.licence,
          keywords: @material.keywords,
          contact: @material.contact,
          status: @material.status
        }
      }
    end
    assert_redirected_to material_path(assigns(:material))
    @material.reload
    assert_nil assigns(:material).space
  end

  test 'should create material with all optional attributes' do
    # reference data
    test_title = 'Test of create with optionals via post'
    test_url = 'https://test.of.create/with/optionals_via_post'
    test_material = materials(:material_with_optionals)
    test_provider = content_providers(:portal_provider)
    assert_not_nil test_material, 'missing reference material'
    assert_not_nil test_provider, 'missing reference provider'

    sign_in users(:regular_user)
    assert_difference('Material.count') do
      post :create, params: {
        material: {

          # required attributes
          title: test_title,
          url: test_url,
          description: test_material.description,
          licence: test_material.licence,
          keywords: test_material.keywords,
          contact: test_material.contact,
          status: test_material.status,

          # optional attributes
          content_provider_id: test_provider.id,
          events: test_material.events,
          target_audience: test_material.target_audience,
          resource_type: test_material.resource_type,
          other_types: test_material.other_types,
          version: test_material.version,
          date_created: test_material.date_created,
          date_modified: test_material.date_modified,
          date_published: test_material.date_published,
          doi: test_material.doi,
          subsets: test_material.subsets,
          authors: test_material.authors.map { |person| { role: person.role, name: person.name, orcid: person.orcid } },
          contributors: test_material.contributors.map { |person| { role: person.role, name: person.name, orcid: person.orcid } },
          prerequisites: test_material.prerequisites,
          syllabus: test_material.syllabus,
          learning_objectives: test_material.learning_objectives
        }
      }
    end
    assert_redirected_to material_path(assigns(:material))

    # check response
    post :check_exists, params: {
      format: :json,
      material: { title: test_title,
                  url: test_url,
                  content_provider_id: test_provider.id }
    }
    assert_response :success
    assert_equal 'application/json; charset=utf-8', response.content_type, 'response content type not matched'

    # required attributes
    assert_equal test_title, JSON.parse(response.body)['title'], 'title not matched.'
    assert_equal test_url, JSON.parse(response.body)['url'], 'description not matched.'
    assert_equal test_material.description, JSON.parse(response.body)['description'], 'description not matched.'
    assert_equal test_material.licence, JSON.parse(response.body)['licence'], 'licence not matched.'
    assert_equal test_material.contact, JSON.parse(response.body)['contact'], 'contact not matched.'
    assert_equal test_material.keywords, JSON.parse(response.body)['keywords'], 'keywords not matched'
    assert_equal test_material.status, JSON.parse(response.body)['status'], 'status not matched'

    # optional attributes
    assert_equal test_material.doi, JSON.parse(response.body)['doi'], 'doi not matched.'
    assert_equal test_provider.id, JSON.parse(response.body)['content_provider_id'], 'provider not matched'
    assert_equal test_material.resource_type, JSON.parse(response.body)['resource_type'], 'resource_type not matched'
    assert_equal test_material.version, JSON.parse(response.body)['version'], 'version not matched'
    assert_equal test_material.other_types, JSON.parse(response.body)['other_types'], 'other_types not matched'
    # assert_equal test_material.events, JSON.parse(response.body)['events'], 'events not matched'
    assert_equal test_material.target_audience, JSON.parse(response.body)['target_audience'], 'target audience not matched'
    response_authors = JSON.parse(response.body)['authors']
    assert_equal test_material.authors.size, response_authors.size, 'authors count not matched'
    response_authors.each_with_index do |author_json, i|
      expected_author = test_material.authors[i]
      assert_equal expected_author.display_name, author_json, "author #{i} name not matched"
    end
    # Contributors is now an array of objects with id, name, orcid
    response_contributors = JSON.parse(response.body)['contributors']
    assert_equal test_material.contributors.size, response_contributors.size, 'contributors count not matched'
    response_contributors.each_with_index do |contributor_json, i|
      expected_contributor = test_material.contributors[i]
      assert_equal expected_contributor.display_name, contributor_json, "contributor #{i} name not matched"
    end
    assert_equal test_material.subsets, JSON.parse(response.body)['subsets'], 'subsets not matched'
    assert_equal test_material.prerequisites, JSON.parse(response.body)['prerequisites'], 'prerequisites not matched'
    assert_equal test_material.syllabus, JSON.parse(response.body)['syllabus'], 'syllabus not matched'
    assert_equal test_material.learning_objectives, JSON.parse(response.body)['learning_objectives'],
                 'learning objectives not matched'
    assert_equal test_material.date_created.to_fs('%Y-%m-%d'), JSON.parse(response.body)['date_created'],
                 'date created not matched'
    assert_equal test_material.date_modified.to_fs('%Y-%m-%d'), JSON.parse(response.body)['date_modified'],
                 'date modified not matched'
    assert_equal test_material.date_published.to_fs('%Y-%m-%d'), JSON.parse(response.body)['date_published'],
                 'date published not matched'

    # reload
    @material.reload
  end

  test 'should create material for admin' do
    sign_in users(:admin)
    assert_difference('Material.count') do
      post :create, params: {
        material: {
          doi: @material.doi,
          remote_created_date: @material.remote_created_date,
          remote_updated_date: @material.remote_updated_date,
          description: @material.description,
          title: @material.title,
          url: @material.url,
          licence: @material.licence,
          keywords: @material.keywords,
          contact: @material.contact,
          status: @material.status
        }
      }
    end
    assert_redirected_to material_path(assigns(:material))
  end

  test 'should not create material for non-logged in user' do
    assert_no_difference('Material.count') do
      post :create, params: {
        material: {
          doi: @material.doi,
          remote_created_date: @material.remote_created_date,
          remote_updated_date: @material.remote_updated_date,
          description: @material.description,
          title: @material.title,
          url: @material.url,
          licence: @material.licence,
          keywords: @material.keywords,
          contact: @material.contact,
          status: @material.status
        }
      }
    end
    assert_redirected_to new_user_session_path
  end

  # SHOW TEST
  test 'should show material' do
    get :show, params: { id: @material }
    assert_response :success
    assert assigns(:material)
    assert_select 'fa-commenting-o', count: 0
    assert_select '.broken-link-notice', count: 0
    assert_select '.archived-notice', count: 0
    assert_select '.learning-path-navigation', count: 0
  end

  test 'should show material as json' do
    @material.scientific_topic_uris = ['http://edamontology.org/topic_0654']
    @material.authors = [{ name: 'Josiah Carberry', orcid: 'https://orcid.org/0000-0002-1825-0097' }, { name: 'Lara Croft' }]
    @material.contributors = [{ name: 'Contri Butor', orcid: '0000-0002-1694-233X' }]
    @material.events << events(:one)
    @material.collections << collections(:one)
    @material.save!

    get :show, params: { id: @material, format: :json }
    assert_response :success
    assert assigns(:material)
    assert_valid_legacy_json_response
    assert_nothing_raised do
      JSON.parse(response.body)
    end
  end

  test 'should show material as json-api' do
    @material.scientific_topic_uris = ['http://edamontology.org/topic_0654']
    @material.events << @event
    @material.collections << @collection
    @material.save!

    get :show, params: { id: @material, format: :json_api }
    assert_response :success
    assert assigns(:material)
    assert_valid_json_api_response
    body = nil
    assert_nothing_raised do
      body = JSON.parse(response.body)
    end

    assert_equal @material.title, body['data']['attributes']['title']
    assert_equal @material.scientific_topic_uris.first, body['data']['attributes']['scientific-topics'].first['uri']
    assert_equal material_path(assigns(:material)), body['data']['links']['self']
    assert_equal @event.id.to_s, body['data']['relationships']['events']['data'][0]['id']
    assert_equal @collection.id.to_s, body['data']['relationships']['collections']['data'][0]['id']
  end

  test 'should show material as bioschemas JSON-LD' do
    @material.scientific_topic_uris = ['http://edamontology.org/topic_0654']
    @material.events << @event
    @material.collections << @collection
    @material.save!

    get :show, params: { id: @material, format: :jsonld }
    assert_response :success
    assert assigns(:material)
    body = nil
    assert_nothing_raised do
      body = JSON.parse(response.body)
    end

    assert_equal 'http://schema.org', body['@context']
    assert_equal 'LearningResource', body['@type']
    assert_equal 'https://bioschemas.org/profiles/TrainingMaterial/1.0-RELEASE', body['dct:conformsTo']['@id']
    assert_equal @material.title, body['name']
    assert_equal @material.url, body['url']
    assert_equal @material.scientific_topic_uris.first, body['about'].first['@id']
    assert_equal material_url(assigns(:material), host: TeSS::Config.base_url), body['@id']
  end

  # UPDATE TEST
  test 'should update material' do
    sign_in @material.user
    patch :update, params: { id: @material, material: @updated_material }
    assert_redirected_to material_path(assigns(:material))
  end

  test 'should update material if curator' do
    sign_in users(:curator)
    assert_not_equal @material.user, users(:curator)
    patch :update, params: { id: @material, material: @updated_material }
    assert_redirected_to material_path(assigns(:material))
  end

  test 'should update material if content provider owner' do
    material = materials(:scraper_user_material)
    user = material.content_provider.user
    assert_not_equal material.user, user
    assert_equal material.content_provider.user, user

    sign_in user
    patch :update, params: { id: material, material: @updated_material }
    assert_redirected_to material_path(assigns(:material))
  end

  test 'should not update material if not owner or curator etc.' do
    sign_in users(:collaborative_user)
    assert_not_equal @material.user, users(:collaborative_user)
    patch :update, params: { id: @material, material: @updated_material }
    assert_response :forbidden
  end

  test 'should update material if approved editor' do
    @material.content_provider.add_editor users(:collaborative_user)
    sign_in users(:collaborative_user)
    assert_not_equal @material.user, users(:curator)
    patch :update, params: { id: @material, material: @updated_material }
    assert_redirected_to material_path(assigns(:material))
  end

  test 'should apply edit suggestions to material' do
    material = materials(:material_with_suggestions)
    sign_in users(:admin)
    assert_empty material.scientific_topics
    refute_nil material.edit_suggestion

    get :show, params: { id: material }
    assert_response :success
    assert_select 'h2', text: 'Material with suggestions', count: 1
    assert_select 'i.fa-commenting-o', count: 1
    assert_select 'ul[data-uri=?]', 'http://edamontology.org/topic_3168', count: 1
    assert_select 'ul[data-uri=?]', 'http://edamontology.org/topic_0199', count: 1

    assert_no_difference('EditSuggestion.count') do
      post :add_term, params: { id: material.id, field: 'scientific_topics', uri: 'http://edamontology.org/topic_3168' }
    end
    assert_response :success

    assert_difference('EditSuggestion.count', -1) do
      post :add_term, params: { id: material.id, field: 'scientific_topics', uri: 'http://edamontology.org/topic_0199' }
    end
    assert_response :success

    assert_nil material.reload.edit_suggestion
  end

  # DESTROY TEST
  test 'should destroy material owned by user' do
    sign_in users(:regular_user)
    assert_difference('Material.count', -1) do
      delete :destroy, params: { id: @material }
    end
    assert_redirected_to materials_path
  end

  test 'should destroy material when administrator' do
    sign_in users(:admin)
    assert_difference('Material.count', -1) do
      delete :destroy, params: { id: @material }
    end
    assert_redirected_to materials_path
  end

  test 'should destroy material if approved editor' do
    @material.content_provider.add_editor users(:another_regular_user)
    sign_in users(:another_regular_user)
    assert_difference('Material.count', -1) do
      delete :destroy, params: { id: @material }
    end
    assert_redirected_to materials_path
  end

  test 'should not destroy material not owned by user' do
    sign_in users(:another_regular_user)
    assert_no_difference('Material.count') do
      delete :destroy, params: { id: @material }
    end
    assert_response :forbidden
  end

  test 'should destroy material when curator' do
    sign_in users(:curator)
    assert_difference('Material.count', -1) do
      delete :destroy, params: { id: @material }
    end
    assert_redirected_to materials_path
  end

  test 'should destroy material when content provider owner' do
    material = materials(:scraper_user_material)
    user = material.content_provider.user

    sign_in user
    assert_difference('Material.count', -1) do
      delete :destroy, params: { id: material }
    end
    assert_redirected_to materials_path
  end

  # CONTENT TESTS
  # BREADCRUMBS
  test 'breadcrumbs for materials index' do
    get :index
    assert_response :success
    assert_select 'div.breadcrumbs', text: /Home/, count: 1 do
      assert_select 'a[href=?]', root_path, count: 1
      assert_select 'li[class=active]', text: /Materials/, count: 1
    end
  end

  test 'breadcrumbs for showing material' do
    get :show, params: { id: @material }
    assert_response :success
    assert_select 'div.breadcrumbs', text: /Home/, count: 1 do
      assert_select 'a[href=?]', root_path, count: 1
      assert_select 'li', text: /Materials/, count: 1 do
        assert_select 'a[href=?]', materials_url, count: 1
      end
      assert_select 'li[class=active]', text: /#{@material.title}/, count: 1
    end
  end

  test 'breadcrumbs for editing material' do
    sign_in users(:regular_user)
    get :edit, params: { id: @material }
    assert_response :success
    assert_select 'div.breadcrumbs', text: /Home/, count: 1 do
      assert_select 'a[href=?]', root_path, count: 1
      assert_select 'li', text: /Materials/, count: 1 do
        assert_select 'a[href=?]', materials_url, count: 1
      end
      assert_select 'li', text: /#{@material.title}/, count: 1 do
        assert_select 'a[href=?]', material_url(@material), count: 1
      end
      assert_select 'li[class=active]', text: /Edit/, count: 1
    end
  end

  test 'breadcrumbs for creating new material' do
    sign_in users(:regular_user)
    get :new
    assert_response :success
    assert_select 'div.breadcrumbs', text: /Home/, count: 1 do
      assert_select 'a[href=?]', root_path, count: 1
      assert_select 'li', text: /Materials/, count: 1 do
        assert_select 'a[href=?]', materials_url, count: 1
      end
      assert_select 'li[class=active]', text: /New/, count: 1
    end
  end

  # OTHER CONTENT

  test 'material has correct layout' do
    get :show, params: { id: @material }
    assert_response :success
    assert_select 'h2', text: @material.title # Has Title
    assert_select 'a.btn', text: 'View material', count: 1 do
      assert_select 'a[href=?]', @material.url, count: 1
    end
    # Should not show when not logged in
    assert_select 'a.btn[href=?]', edit_material_path(@material), count: 0 # No Edit
    assert_select 'a.btn[href=?]', material_path(@material), count: 0 # No Edit
  end

  test 'do not show action buttons when not owner or admin' do
    sign_in users(:another_regular_user)
    get :show, params: { id: @material }
    assert_select 'a.btn[href=?]', edit_material_path(@material), count: 0 # No Edit
    assert_select 'a.btn[href=?]', material_path(@material), count: 0 # No Edit
  end

  test 'show action buttons when owner' do
    sign_in users(:regular_user)
    get :show, params: { id: @material }
    assert_select 'a.btn[href=?]', edit_material_path(@material), count: 1
    assert_select 'a.btn[href=?]', material_path(@material), text: 'Delete', count: 1
  end

  test 'show action buttons when admin' do
    sign_in users(:admin)
    get :show, params: { id: @material }
    assert_select 'a.btn[href=?]', edit_material_path(@material), count: 1
    assert_select 'a.btn[href=?]', material_path(@material), text: 'Delete', count: 1
  end

  test 'show action buttons when approved editor' do
    @material.content_provider.add_editor users(:another_regular_user)
    sign_in users(:another_regular_user)
    get :show, params: { id: @material }
    assert_select 'a.btn[href=?]', edit_material_path(@material), count: 1
    assert_select 'a.btn[href=?]', material_path(@material), text: 'Delete', count: 1
  end

  # API Actions
  test 'should find existing material by title and content provider' do
    post :check_exists, params: {
      format: :json,
      material: { title: @material.title,
                  url: 'whatever.com',
                  content_provider_id: @material.content_provider_id }
    }
    assert_response :success
    assert_equal(JSON.parse(response.body)['id'], @material.id)
  end

  test 'should find existing material by url' do
    post :check_exists, params: {
      format: :json,
      material: { title: 'whatever',
                  url: @material.url,
                  content_provider_id: @material.content_provider_id }
    }
    assert_response :success
    assert_equal(JSON.parse(response.body)['id'], @material.id)
  end

  test 'should find existing material by url without provider' do
    post :check_exists, params: { format: :json, material: { title: 'whatever', url: @material.url } }
    assert_response :success
    assert_equal(JSON.parse(response.body)['url'], @material.url)
    assert_equal(JSON.parse(response.body)['id'], @material.id)
  end

  test 'should find existing material by url and given content provider' do
    provider1 = content_providers(:iann)
    provider2 = content_providers(:two)

    e1 = provider1.materials.create!(title: 'another material', url: @material.url, description: '123', user: users(:regular_user))
    e2 = provider2.materials.create!(title: 'a third material', url: @material.url, description: '123', user: users(:regular_user))

    post :check_exists, params: { format: :json, material: { url: @material.url, content_provider_id: provider1.id } }
    assert_response :success
    assert_equal(JSON.parse(response.body)['id'], e1.id)

    post :check_exists, params: { format: :json, material: { url: @material.url, content_provider_id: provider2.id } }
    assert_response :success
    assert_equal(JSON.parse(response.body)['id'], e2.id)
  end

  test 'should return nothing when material does not exist' do
    post :check_exists, params: {
      format: :json,
      material: { url: 'http://no-such-url.com' }
    }
    assert_response :success
    assert_equal '{}', response.body
  end

  test 'should render properly when no url supplied' do
    post :check_exists, params: {
      format: :json,
      material: { url: nil }
    }
    assert_response :success
    assert_equal '{}', response.body
  end

  test 'should display filters on index' do
    get :index
    assert_select 'h4.nav-heading', text: /Content provider/, count: 0
    assert_select 'li.masonry-brick', count: Material.count
  end

  test 'should create new material through API' do
    scraper_role = Role.fetch('scraper_user')
    scraper_user = User.where(role_id: scraper_role.id).first
    material_title = 'horse'
    assert scraper_user
    assert_difference('Material.count') do
      post :create, params: {
        user_token: scraper_user.authentication_token,
        user_email: scraper_user.email,
        material: {
          title: material_title,
          url: 'http://horse.com',
          description: 'I love horses',
          contact: 'default contact',
          doi: 'https://doi.org/10.1001/RSE.2.190',
          licence: 'CC-BY-4.0',
          keywords: %w[scraped through api],
          status: 'active'
        },
        format: 'json'
      }
    end
    assert_equal material_title, JSON.parse(response.body)['title']
  end

  test 'should not create new material without valid authentication token' do
    scraper_role = Role.fetch('scraper_user')
    scraper_user = User.where(role_id: scraper_role.id).first
    assert scraper_user

    assert_no_difference('Material.count') do
      post :create, params: {
        user_token: 'made up authentication token',
        user_email: scraper_user.email,
        material: {
          title: 'material_title',
          url: 'http://horse.com',
          description: 'All about horses',
          contact: 'default contact',
          doi: 'https://doi.org/10.1001/RSE.2.190',
          licence: 'CC-BY-4.0',
          keywords: %( invalid authtoken ),
          status: 'active'
        },
        format: 'json'
      }
    end
    assert_response 401
  end

  test 'should update existing material through API' do
    user = users(:scraper_user)
    material = materials(:scraper_user_material)

    new_title = 'totally new title'
    assert_no_difference('Material.count') do
      patch :update, params: {
        user_token: user.authentication_token,
        user_email: user.email,
        material: {
          title: new_title,
          url: material.url,
          description: material.description
        },
        id: material.id,
        format: 'json'
      }
    end
    assert_not_equal material.title, JSON.parse(response.body)['title']
    assert_equal new_title, JSON.parse(response.body)['title']
  end

  test 'should not update non scraper owner through API' do
    user = users(:regular_user)
    other_user = users(:another_regular_user)
    material = user.materials.first

    new_title = 'totally new title'
    assert_no_difference('Material.count') do
      patch :update, params: {
        user_token: other_user.authentication_token,
        user_email: other_user.email,
        material: {
          title: new_title,
          url: material.url,
          description: material.description
        },
        id: material.id,
        format: 'json'
      }
    end
    assert_response 401
  end

  test 'should add material to multiple collections' do
    sign_in @material.user
    collection1 = collections(:one)
    collection1_material_count = collection1.materials.count
    collection2 = collections(:two)
    @material.collections = []
    @material.save!
    assert_difference('@material.collections.count', 2) do
      post :update_collections, params: {
        id: @material.id,
        material: {
          collection_ids: [collection1.id, collection2.id]
        }
      }
    end
    assert_in_delta(collection1.materials.count, collection1_material_count, 1)
  end

  test 'should remove material from collections' do
    sign_in @material.user
    collection1 = collections(:one)
    collection1_material_count = collection1.materials.count
    collection2 = collections(:two)
    @material.collections << [collection1, collection2]
    @material.save

    assert_difference('@material.collections.count', -2) do
      post :update_collections, params: {
        id: @material.id,
        material: {
          collection_ids: ['']
        }
      }
    end
    assert_in_delta(collection1.materials.count, collection1_material_count, 1)
  end

  test 'should add external resource to material' do
    sign_in @material.user

    assert_difference('ExternalResource.count', 1) do
      patch :update, params: {
        id: @material,
        material: {
          title: 'New title',
          description: 'New description',
          url: 'http://new.url.com',
          content_provider_id: ContentProvider.first.id,
          external_resources_attributes: { '1' => { title: 'Cool link', url: 'https://tess.elixir-uk.org/', _destroy: '0' } }
        }
      }
    end

    assert_redirected_to material_path(assigns(:material))
    resource = assigns(:material).external_resources.first
    assert_equal 'Cool link', resource.title
    assert_equal 'https://tess.elixir-uk.org/', resource.url
  end

  test 'should remove external resource from material' do
    material = materials(:material_with_external_resource)
    resource = material.external_resources.first
    count = material.external_resources.count
    sign_in material.user

    assert_difference('ExternalResource.count', -1) do
      patch :update, params: {
        id: material,
        material: {
          title: 'New title',
          description: 'New description',
          url: 'http://new.url.com',
          content_provider_id: ContentProvider.first.id,
          external_resources_attributes: { '0' => { id: resource.id, _destroy: '1' } }
        }
      }
    end

    assert_redirected_to material_path(assigns(:material))
    assert_equal count - 1, assigns(:material).external_resources.count
  end

  test 'should modify external resource from material' do
    material = materials(:material_with_external_resource)
    resource = material.external_resources.first
    sign_in material.user

    assert_no_difference('ExternalResource.count') do
      patch :update, params: {
        id: material,
        material: {
          title: 'New title',
          description: 'New description',
          url: 'http://new.url.com',
          content_provider_id: ContentProvider.first.id,
          external_resources_attributes: { '1' => { id: resource.id, title: 'Cool link',
                                                    url: 'http://www.reddit.com', _destroy: '0' } }
        }
      }
    end

    assert_redirected_to material_path(assigns(:material))
    assert_equal 'Cool link', resource.reload.title
    assert_equal 'http://www.reddit.com', resource.url
  end

  # TODO: SOLR tests will not run on TRAVIS. Explore stratergy for testing solr
  #       test 'should return matching materials' do
  #         get 'index', :format => :json, :q => 'training'
  #         assert_response :success
  #         assert response.body.size > 0
  #       end
  #
  #       test 'should return no matching materials' do
  #         get 'index', :format => :json, :q => 'kdfsajfklasdjfljsdfljdsfjncvmn'
  #         assert_response :success
  #         assert_equal(response.body,'[]')
  #         end
  test 'finds multiple preferred labels' do
    topic_one = Edam::Ontology.instance.lookup('http://edamontology.org/topic_0154')
    topic_two = Edam::Ontology.instance.lookup('http://edamontology.org/topic_0078')
    topics = [topic_one.preferred_label, topic_two.preferred_label]
    @material.scientific_topic_names = topics
    assert_not_empty @material.scientific_topics
    assert_equal [topic_one, topic_two], @material.scientific_topics
  end
  test 'finds single preferred label' do
    topic_one = Edam::Ontology.instance.lookup('http://edamontology.org/topic_0154')
    topics = topic_one.preferred_label
    @material.scientific_topic_names = topics
    assert_not_empty @material.scientific_topics
    assert_equal [topic_one], @material.scientific_topics
  end

  test 'find scientific topic that has an exact synonym of parameter' do
    synonym_topic = Edam::Ontology.instance.lookup('http://edamontology.org/topic_0092')
    topics = synonym_topic.has_exact_synonym
    @material.scientific_topic_names = topics
    assert_equal [synonym_topic], @material.scientific_topics
  end

  test 'find scientific topic that is a narrow synonym of parameter' do
    narrow_topic = Edam::Ontology.instance.lookup('http://edamontology.org/topic_3957')
    topics = narrow_topic.has_narrow_synonym
    @material.scientific_topic_names = topics
    assert_equal [narrow_topic], @material.scientific_topics
  end

  test 'set topics to nil if empty array passed' do
    topics = []
    @material.scientific_topic_names = topics
    assert_empty @material.scientific_topics
  end

  test 'should sanitize descriptions when creating material' do
    sign_in @user

    assert_difference('Material.count', 1) do
      post :create, params: {
        material: { description: '<b>hi</b><script>alert("hi!");</script>',
                    title: 'Insanity',
                    url: 'http://www.example.com/sanity/0',
                    doi: 'https://doi.org/10.1100/RSE.2019.23',
                    licence: 'CC-BY-4.0',
                    keywords: %w[insanity sanitized sanitary],
                    contact: 'default contact',
                    status: 'development' }
      }
    end

    assert_redirected_to material_path(assigns(:material))
    assert_equal 'hi', assigns(:material).description
  end

  test 'should log parameter changes when updating a material' do
    sign_in @material.user
    @material.activities.destroy_all

    # 5 = 4 for parameters + 1 for update
    assert_difference('PublicActivity::Activity.count', 5) do
      patch :update, params: { id: @material, material: @updated_material }
    end

    assert_equal 1, @material.activities.where(key: 'material.update').count
    assert_equal 4, @material.activities.where(key: 'material.update_parameter').count

    parameters = @material.activities.where(key: 'material.update_parameter').map(&:parameters)
    title_activity = parameters.detect { |p| p[:attr] == 'title' }
    url_activity = parameters.detect { |p| p[:attr] == 'url' }
    description_activity = parameters.detect { |p| p[:attr] == 'description' }
    content_provider_activity = parameters.detect { |p| p[:attr] == 'content_provider_id' }

    assert_equal 'New title', title_activity[:new_val]
    assert_equal 'http://new.url.com', url_activity[:new_val]
    assert_equal 'New description', description_activity[:new_val]
    assert_equal ContentProvider.first.id, content_provider_activity[:new_val]
    assert_equal ContentProvider.first.title, content_provider_activity[:association_name]

    old_controller = @controller
    @controller = ActivitiesController.new

    get :index, params: { material_id: @material }, xhr: true

    assert_select '.activity', count: 5

    @controller = old_controller
  end

  test 'parameter log activity works when removing an association' do
    sign_in @material.user
    @material.activities.destroy_all

    assert_difference('PublicActivity::Activity.count', 2) do
      # 2 = 1 for parameters + 1 for update
      patch :update, params: { id: @material, material: { content_provider_id: nil } }
    end

    assert_equal 1, @material.activities.where(key: 'material.update').count
    assert_equal 1, @material.activities.where(key: 'material.update_parameter').count

    parameters = @material.activities.where(key: 'material.update_parameter').map(&:parameters)
    content_provider_activity = parameters.detect { |p| p[:attr] == 'content_provider_id' }

    assert content_provider_activity[:new_val].blank?
    assert content_provider_activity[:association_name].blank?

    old_controller = @controller
    @controller = ActivitiesController.new

    get :index, params: { material_id: @material }, xhr: true

    assert_select '.activity', count: 2

    @controller = old_controller
  end

  test 'should not log an update when only boring fields have changed' do
    sign_in @material.user
    @material.activities.destroy_all

    assert_no_difference('PublicActivity::Activity.count') do
      patch :update, params: { id: @material, material: { last_scraped: Time.now } }
    end
  end

  test 'can assign nodes by name' do
    sign_in users(:regular_user)

    assert_difference('Material.count') do
      post :create, params: {
        material: {
          description: @material.description,
          title: @material.title,
          url: @material.url,
          node_names: [nodes(:westeros).name, nodes(:good).name],
          doi: @material.doi,
          licence: @material.licence,
          keywords: @material.keywords,
          contact: @material.contact,
          status: @material.status
        }
      }
    end
    assert_redirected_to material_path(assigns(:material))

    assert_includes assigns(:material).node_ids, nodes(:westeros).id
    assert_includes assigns(:material).node_ids, nodes(:good).id
  end

  test 'can lock fields' do
    sign_in @material.user
    assert_difference('FieldLock.count', 2) do
      patch :update, params: { id: @material, material: { title: 'hi', locked_fields: %w[title description] } }
    end

    assert_redirected_to material_path(assigns(:material))
    assert_equal 2, assigns(:material).locked_fields.count
    assert assigns(:material).field_locked?(:title)
    assert assigns(:material).field_locked?(:description)
    refute assigns(:material).field_locked?(:url)
  end

  test 'scraper cannot overwrite locked fields' do
    user = users(:scraper_user)
    material = materials(:scraper_user_material)
    material.locked_fields = [:title]
    material.save!

    assert_no_difference('Material.count') do
      patch :update, params: {
        user_token: user.authentication_token,
        user_email: user.email,
        material: {
          title: 'new title',
          url: material.url,
          description: 'new description'
        },
        id: material.id,
        format: 'json'
      }
    end

    parsed_response = JSON.parse(response.body)
    assert_equal material.title, parsed_response['title'], 'Title should not have changed'
    assert_equal 'new description', parsed_response['description']
  end

  test 'normal user can overwrite locked fields' do
    @material.locked_fields = [:title]
    @material.save!

    sign_in @material.user
    patch :update, params: { id: @material, material: { title: 'new title' } }
    assert_redirected_to material_path(assigns(:material))

    assert_equal 'new title', assigns(:material).title
  end

  test 'should count index results' do
    with_settings(solr_enabled: true) do
      materials = Material.all

      Material.stub(:search_and_filter, MockSearch.new(materials)) do
        get :count, params: { format: :json }
        output = JSON.parse(response.body)

        assert_response :success
        assert_equal materials.count, output['count']
        assert_equal materials_url, output['url']
      end
    end
  end

  test 'should count filtered results' do
    with_settings(solr_enabled: true) do
      materials = Material.limit(3)

      Material.stub(:search_and_filter, MockSearch.new(materials)) do
        get :count, params: { q: 'test', keywords: 'dolphins', blabla: 'booboo', format: :json }
        output = JSON.parse(response.body)

        assert_response :success
        assert_equal materials.count, output['count']
        assert_equal materials_url(q: 'test', keywords: 'dolphins'), output['url']
        assert_equal 'dolphins', output['params']['keywords']
      end
    end
  end

  test 'should approve topic for curator' do
    sign_in users(:curator)

    assert_empty @material.scientific_topic_names

    suggestion = @material.build_edit_suggestion
    suggestion.scientific_topic_uris = ['http://edamontology.org/topic_0622']
    suggestion.save!

    assert_difference('EditSuggestion.count', -1) do
      post :add_term, params: { id: @material.id, field: 'scientific_topics', uri: 'http://edamontology.org/topic_0622' }
    end

    assert_response :success

    assert_equal ['Genomics'], @material.reload.scientific_topic_names
    assert_nil @material.reload.edit_suggestion
  end

  test 'should reject topic for curator' do
    sign_in users(:curator)

    assert_empty @material.scientific_topic_names

    suggestion = @material.build_edit_suggestion
    suggestion.scientific_topic_uris = ['http://edamontology.org/topic_0622']
    suggestion.data_fields = {}
    suggestion.data_fields[:latitude] = '53.141969'
    suggestion.data_fields[:longitude] = '0.3418338'
    suggestion.save!

    assert_difference('EditSuggestion.count', 0) do
      post :reject_term, params: { id: @material.id, field: 'scientific_topics', uri: 'http://edamontology.org/topic_0622' }
    end

    assert_response :success

    assert_difference('EditSuggestion.count', 0) do
      post :reject_data, params: { id: @material.id, data_field: 'latitude', data_value: '53.141969' }
    end

    assert_response :success

    assert_difference('EditSuggestion.count', -1) do
      post :reject_data, params: { id: @material.id, data_field: 'longitude', data_value: '0.3418338' }
    end

    assert_response :success

    assert_empty @material.reload.scientific_topic_names
    assert_nil @material.reload.edit_suggestion
  end

  test 'should not approve topic for unprivileged user' do
    sign_in users(:another_regular_user)

    assert_empty @material.scientific_topic_names

    suggestion = @material.build_edit_suggestion
    suggestion.scientific_topic_uris = ['http://edamontology.org/topic_0622']
    suggestion.save!

    assert_no_difference('EditSuggestion.count') do
      post :add_term, params: { id: @material.id, field: 'scientific_topics', uri: 'http://edamontology.org/topic_0622' }
    end

    assert_response :forbidden

    assert_empty @material.reload.scientific_topic_names
    assert_equal ['Genomics'], @material.reload.edit_suggestion.scientific_topic_names
  end

  test 'should not reject topic for unprivileged user' do
    sign_in users(:another_regular_user)

    assert_empty @material.scientific_topic_names

    suggestion = @material.build_edit_suggestion
    suggestion.scientific_topic_uris = ['http://edamontology.org/topic_0622']
    suggestion.save!

    assert_no_difference('EditSuggestion.count') do
      post :reject_term, params: { id: @material.id, field: 'scientific_topics', uri: 'http://edamontology.org/topic_0622' }
    end

    assert_response :forbidden

    assert_empty @material.reload.scientific_topic_names
    assert_equal ['Genomics'], @material.reload.edit_suggestion.scientific_topic_names
  end

  test 'should trigger notification when unverified user creates material' do
    sign_in users(:unverified_user)

    assert_enqueued_jobs 1 do
      assert_difference('Material.count') do
        post :create, params: {
          material: { description: @material.description,
                      title: @material.title,
                      url: 'http://example.com/dodgy-event',
                      doi: 'https://doi.org/10.10067/SEA.2019.22',
                      licence: 'CC-BY-4.0',
                      keywords: %w[dodgy event],
                      contact: 'default contact',
                      status: 'archived' }
        }
      end
    end

    assert_redirected_to material_path(assigns(:material))
    @material.reload
  end

  test 'should not trigger notification if unverified user already created content' do
    sign_in users(:unverified_user)
    users(:unverified_user).materials.create!(description: @material.description,
                                              title: @material.title, url: 'http://example.com/dodgy-event',
                                              doi: 'https://doi.org/10.10067/SEA.2019.22', status: 'active',
                                              licence: 'CC-BY-4.0', contact: 'default contact',
                                              keywords: %w[dodgy event unverified user])

    assert_enqueued_jobs 0 do
      assert_difference('Material.count') do
        post :create, params: {
          material: { description: @material.description,
                      title: @material.title, url: 'http://example.com/dodgy-event-2',
                      licence: 'CC-BY-4.0', contact: 'default contact', status: 'active',
                      doi: 'https://doi.org/10.10067/SEA.2019.22',
                      keywords: %w[another dodgy event] }
        }
      end
    end

    assert_redirected_to material_path(assigns(:material))
    @material.reload
  end

  test 'can view material with external resources' do
    material = materials(:material_with_external_resource)
    get :show, params: { id: material }
    assert_response :success

    assert_select '.external-resources-box div.bounding-box', count: material.external_resources.count
  end

  test 'should show identifiers dot org button for material' do
    get :show, params: { id: @material }

    assert_response :success
    assert_select '.identifiers-button'
    assert_select '#identifiers-link[value=?]', "http://example.com/identifiers/banana:m#{@material.id}"
  end

  test 'should support legacy clients using short_description and long_description' do
    scraper_user = users(:scraper_user)
    material_title = 'horse'
    assert_difference('Material.count') do
      post :create, params: {
        user_token: scraper_user.authentication_token,
        user_email: scraper_user.email,
        material: {
          title: material_title,
          url: 'http://horse.com',
          short_description: 'I love horses',
          long_description: 'I really love horses',
          contact: 'default contact',
          doi: 'https://doi.org/10.1001/RSE.2.190',
          licence: 'CC-BY-4.0',
          keywords: %w[scraped through api],
          status: 'active'
        },
        format: 'json'
      }
    end

    assert_equal 'I really love horses', JSON.parse(response.body)['description']
  end

  test 'can render embedded youtube video' do
    sign_in users(:regular_user)
    get :show, params: { id: materials(:youtube_video_material) }
    assert_response :success

    assert_select 'div.embedded-content iframe[src=?]', 'https://www.youtube.com/embed/1T_2xMTQCv4'
  end

  test 'no embedded content section if not available' do
    sign_in users(:regular_user)
    get :show, params: { id: materials(:good_material) }
    assert_response :success

    assert_select 'div.embedded-content', count: 0
  end

  test 'can scope index according to e-learning if enabled' do
    with_settings(solr_enabled: true, feature: { elearning_materials: true }) do
      Material.stub(:search_and_filter, MockSearch.new(Material.all)) do
        get :index, params: { resource_type: 'e-learning' }

        assert_response :success
      end
    end

    assert_select '#content h2', text: 'e-Learning'
    assert_select '.searchbox-sm form[action=?]', elearning_materials_path do
      assert_select '#q[placeholder=?]', 'Search e-learning materials...'
    end
  end

  test 'does not scope index according to e-learning if not enabled' do
    with_settings(solr_enabled: true, feature: { elearning_materials: false }) do
      Material.stub(:search_and_filter, MockSearch.new(Material.all)) do
        get :index, params: { resource_type: 'e-learning' }

        assert_response :success
      end
    end

    assert_select '#content h2', text: 'Training materials'
    assert_select '.searchbox-sm form[action=?]', materials_path do
      assert_select '#q[placeholder=?]', 'Search materials...'
    end
  end

  test 'should clone material' do
    sign_in @material.user
    get :clone, params: { id: @material }
    assert_response :success
    assert_nil assigns(:material).url
    assert_nil assigns(:material).id
    assert_equal @material.title, assigns(:material).title
    assert_select '#material_title[value=?]', @material.title
  end

  test 'should not clone material if no permission' do
    sign_in users(:another_regular_user)
    get :clone, params: { id: @material }
    assert_response :forbidden
  end

  test 'should hide fields' do
    with_settings(feature: { materials_disabled: %w[licence scientific_topics resource_type] }) do
      sign_in users(:regular_user)
      get :new
      assert_response :success
      assert_select 'div.hidden' do |_div|
        assert_select 'label', text: 'Licence', count: 1
        assert_select 'label', text: 'Status', count: 0
      end
      assert_select 'div.hidden' do |el|
        assert_select el, 'label', text: 'Resource types', count: 1
        assert_select el, 'label', text: 'Scientific topics', count: 1
        assert_select el, 'label', text: 'Keywords', count: 0
        assert_select el, 'label', text: 'Operations', count: 0
      end
      assert_select 'label', { count: 1, text: 'Status' }
      assert_select 'label', { count: 1, text: 'Keywords' }
      assert_select 'label', { count: 1, text: 'Operations' }
    end
  end

  test 'should display archived warning' do
    material = materials(:material_with_external_resource)
    assert material.archived?

    get :show, params: { id: material }

    assert_response :success
    assert_select '.archived-notice', text: /material has been archived/
  end

  test 'should preview material' do
    sign_in users(:regular_user)

    assert_no_difference('Material.count') do
      assert_no_difference('ExternalResource.count') do
        post :preview, params: { material: { title: 'Potential material',
                                             url: 'https://somematerial.com',
                                             description: 'hey',
                                             external_resources_attributes: [
                                               { title: 'A tool perhaps', url: 'https://bio.tools/some_tool' }
                                             ] } }

        assert_response :success
        assert_select 'h2', text: 'Potential material'
        assert_select '.external-resources-box a[href=?]', 'https://bio.tools/some_tool'
      end
    end
  end

  test 'should not preview invalid material' do
    sign_in users(:regular_user)

    assert_no_difference('Material.count') do
      assert_no_difference('ExternalResource.count') do
        post :preview, params: { material: { title: 'Missing URL', description: 'hey' } }

        assert_response :unprocessable_entity
      end
    end
  end

  test 'should show unverified users material to themselves' do
    sign_in users(:unverified_user)
    material = users(:unverified_user).materials.create!(description: @material.description,
                                                         title: @material.title, url: 'http://example.com/dodgy-event',
                                                         doi: 'https://doi.org/10.10067/SEA.2019.22', status: 'active',
                                                         licence: 'CC-BY-4.0', contact: 'default contact',
                                                         keywords: %w[dodgy event unverified user])

    get :show, params: { id: material }

    assert_response :success
    assert_select '.unverified-notice',
                  text: 'This material will not be publicly visible until your registration has been approved by an administrator.'
  end

  test 'should show unverified users material to admin' do
    material = users(:unverified_user).materials.create!(description: @material.description,
                                                         title: @material.title, url: 'http://example.com/dodgy-event',
                                                         doi: 'https://doi.org/10.10067/SEA.2019.22', status: 'active',
                                                         licence: 'CC-BY-4.0', contact: 'default contact',
                                                         keywords: %w[dodgy event unverified user])
    sign_in users(:admin)

    get :show, params: { id: material }

    assert_response :success
    assert_select '.unverified-notice',
                  text: 'This material will not be publicly visible until your registration has been approved by an administrator.'
  end

  test 'should not show unverified users material anon user' do
    material = users(:unverified_user).materials.create!(description: @material.description,
                                                         title: @material.title, url: 'http://example.com/dodgy-event',
                                                         doi: 'https://doi.org/10.10067/SEA.2019.22', status: 'active',
                                                         licence: 'CC-BY-4.0', contact: 'default contact',
                                                         keywords: %w[dodgy event unverified user])

    get :show, params: { id: material }
    assert_response :forbidden
  end

  test 'should show learning path nav and link to next item' do
    learning_path = learning_paths(:one)
    topic_link = learning_path.topic_links.first
    topic_item = topic_link.topic.material_items.first
    material = topic_item.resource

    get :show, params: { id: material, lp: [topic_link, topic_item].map(&:id).join(':') }

    assert_response :success
    assert assigns(:learning_path_topic_link)
    assert assigns(:learning_path_topic_item)

    next_item = assigns(:learning_path_topic_item).next_item
    assert next_item

    assert_select '.learning-path-navigation'
    assert_select 'strong', text: 'Next:'
    assert_select 'strong', text: 'Next topic:', count: 0
    assert_select '.learning-path-navigation a[href=?]',
                  material_path(next_item.resource, lp: [topic_link, next_item].map(&:id).join(':'))
  end

  test 'learning path nav should link to next topic' do
    learning_path = learning_paths(:one)
    topic_link = learning_path.topic_links.first
    topic_item = topic_link.topic.material_items.last
    material = topic_item.resource

    get :show, params: { id: material, lp: [topic_link, topic_item].map(&:id).join(':') }

    assert_response :success
    assert assigns(:learning_path_topic_link)
    assert assigns(:learning_path_topic_item)

    next_topic = assigns(:learning_path_topic_link).next_topic
    assert next_topic
    refute assigns(:learning_path_topic_item).next_item

    assert_select '.learning-path-navigation'
    assert_select 'strong', text: 'Next:', count: 0
    assert_select 'strong', text: 'Next topic:'
    assert_select '.learning-path-navigation a[href=?]',
                  learning_path_path(learning_path, anchor: "topic-#{next_topic.id}")
  end

  test 'learning path nav should indicate if final item in learning path' do
    learning_path = learning_paths(:one)
    topic_link = learning_path.topic_links.last
    topic_item = topic_link.topic.material_items.last
    material = topic_item.resource

    get :show, params: { id: material, lp: [topic_link, topic_item].map(&:id).join(':') }

    assert_response :success
    assert assigns(:learning_path_topic_link)
    assert assigns(:learning_path_topic_item)
    refute assigns(:learning_path_topic_link).next_topic
    refute assigns(:learning_path_topic_item).next_item

    assert_select '.learning-path-navigation'
    assert_select 'strong', text: 'Next:', count: 0
    assert_select 'strong', text: 'Next topic:', count: 0
    assert_select 'span.empty', text: 'End of learning path'
  end

  test 'should limit displayed keywords on index page' do
    keywords = 10.times.map { |i| "keyword_#{i}" }
    @material.keywords = keywords + ['extra_keyword']
    @material.save!

    with_settings(solr_enabled: true) do
      Material.stub(:search_and_filter, MockSearch.new([@material])) do
        get :index
        assert_response :success
        assert_includes assigns(:materials), @material
        assert_select '.label', text: 'keyword_3'
        assert_select '.label', text: 'keyword_9'
        assert_select '.label', text: 'extra_keyword', count: 0
      end
    end
  end

  test 'should create material in current space' do
    plant_space = spaces(:plants)
    with_host(plant_space.host) do
      sign_in users(:regular_user)
      assert_difference('Material.count') do
        post :create, params: {
          material: {
            doi: @material.doi,
            remote_created_date: @material.remote_created_date,
            remote_updated_date: @material.remote_updated_date,
            description: @material.description,
            title: @material.title,
            url: @material.url,
            licence: @material.licence,
            keywords: @material.keywords,
            contact: @material.contact,
            status: @material.status
          }
        }
      end
      assert_redirected_to material_path(assigns(:material))
      assert_equal plant_space, assigns(:material).space
    end
  end

  test 'should display material authors/contributors appropriately' do
    assert @material.update(authors: [{ name: 'John Doe' },
                                      { name: 'Jane Smith', orcid: '0000-0001-9999-9990' }],
                            contributors: [{ name: 'Jos Ca', orcid: '0000-0002-1825-0097' }])

    get :show, params: { id: @material.id }

    assert_select '.authors', text: 'Authors: John Doe, Jane Smith'
    assert_select '.authors a', count: 1 do
      assert_select '[href=?]', 'https://orcid.org/0000-0001-9999-9990'
    end

    assert_select '.contributors', { text: 'Contributors: Josiah Carberry' },
                  "Should use name from person's profile, if linked"
    assert_select '.contributors a', count: 1 do
      assert_select '[href=?]', trainer_path(profiles(:trainer_one_profile))
    end
  end

  test 'should display non-trainer contributor with linked ORCID' do
    jc = profiles(:trainer_one_profile)
    jc.update!(public: false, website: nil, image_url: nil)
    jc = Profile.find(jc.id)
    assert @material.update(authors: [{ name: 'John Doe' },
                                      { name: 'Jane Smith', orcid: '0000-0001-9999-9990' }],
                            contributors: [{ name: 'Jos Ca', orcid: '0000-0002-1825-0097' }])

    get :show, params: { id: @material.id }

    assert_select '.authors', text: 'Authors: John Doe, Jane Smith'
    assert_select '.authors a', count: 1 do
      assert_select '[href=?]', 'https://orcid.org/0000-0001-9999-9990'
    end

    assert_select '.contributors', { text: 'Contributors: Josiah Carberry' },
                  "Should use name from person's profile, if linked"
    assert_select '.contributors a', count: 1 do
      assert_select '[href=?]', user_path(jc.user)
    end
  end

  test 'should update material authors using structured authors' do
    sign_in @material.user
    update = @updated_material.merge(authors: [
                                       { name: 'Joe', orcid: '0000-0002-1825-0097' }
                                     ])
    patch :update, params: { id: @material, material: update }
    mat = assigns(:material)
    assert_redirected_to material_path(mat)
    assert_equal update[:authors].first[:name], mat.authors.first[:name]
    assert_equal update[:authors].first[:orcid], mat.authors.first[:orcid]
  end

  test 'should update material authors using string array of authors' do
    sign_in @material.user
    update = @updated_material.merge(authors: ['Joe'])
    patch :update, params: { id: @material, material: update }
    mat = assigns(:material)
    assert_redirected_to material_path(mat)
    assert_equal 'Joe', mat.authors.first[:name]
    assert_nil mat.authors.first[:orcid]
  end

  test 'should update material authors using param structured authors' do
    material = materials(:material_with_optionals)
    sign_in material.user
    update = { authors: { '1234' => {
      name: 'Joe', orcid: '0000-0002-1825-0097'
    } } }
    patch :update, params: { id: material, material: update }
    mat = assigns(:material)
    assert_redirected_to material_path(mat)

    assert_equal 'Joe', mat.authors.first[:name]
    assert_equal '0000-0002-1825-0097', mat.authors.first[:orcid]
  end

  test 'should render scientific topics and operations as links in extra metadata' do
    @material.scientific_topic_uris = ['http://edamontology.org/topic_0622'] # Genomics
    @material.operation_uris = ['http://edamontology.org/operation_0292'] # Sequence alignment
    @material.save!

    get :show, params: { id: @material }
    assert_response :success

    assert_select 'p.scientific_topics a[href="http://edamontology.org/topic_0622"]', text: 'Genomics'
    assert_select 'p.operations a[href="http://edamontology.org/operation_0292"]', text: 'Sequence alignment'
  end
end