Example #1
0
def test_orcid_push_triggered_on_create_record_with_multiple_authors_with_allow_push(
    mock_orcid_push_task,
    inspire_app,
    raw_record,
    two_users_with_permission,
    enable_orcid_push_feature,
):
    migrate_and_insert_record(raw_record)

    expected_kwargs_user1 = {
        "kwargs": {
            "orcid": two_users_with_permission[0]["orcid"],
            "rec_id": 1608652,
            "oauth_token": two_users_with_permission[0]["token"],
            "kwargs_to_pusher": {
                "record_db_version": mock.ANY
            },
        }
    }
    expected_kwargs_user2 = {
        "kwargs": {
            "orcid": two_users_with_permission[1]["orcid"],
            "rec_id": 1608652,
            "oauth_token": two_users_with_permission[1]["token"],
            "kwargs_to_pusher": {
                "record_db_version": mock.ANY
            },
        }
    }

    mock_orcid_push_task.assert_any_call(**expected_kwargs_user1)
    mock_orcid_push_task.assert_any_call(**expected_kwargs_user2)
    assert mock_orcid_push_task.call_count == 2
def test_migrate_and_insert_record_invalid_record_update_regression(
        inspire_app):
    # test is not isolated so the models_committed signal fires and the indexer might be called
    raw_record = (
        b"<record>"
        b'  <controlfield tag="001">12345</controlfield>'
        b'  <datafield tag="245" ind1=" " ind2=" ">'
        b'    <subfield code="a">On the validity of INSPIRE records</subfield>'
        b"  </datafield>"
        b'  <datafield tag="980" ind1=" " ind2=" ">'
        b'    <subfield code="a">HEP</subfield>'
        b"  </datafield>"
        b"</record>")

    migrate_and_insert_record(raw_record)

    raw_record = (b"<record>"
                  b'  <controlfield tag="001">12345</controlfield>'
                  b'  <datafield tag="980" ind1=" " ind2=" ">'
                  b'    <subfield code="a">HEP</subfield>'
                  b"  </datafield>"
                  b"</record>")

    with patch("inspirehep.indexer.base.InspireRecordIndexer") as mock_indexer:
        migrate_and_insert_record(raw_record)

        prod_record = LegacyRecordsMirror.query.filter(
            LegacyRecordsMirror.recid == 12345).one()
        assert prod_record.valid is False
        assert prod_record.marcxml == raw_record

        assert not mock_indexer.return_value.index.called
def test_migrator_deleted_deleted_records_correctly_when_pid_redirection_is_turned_off(
        inspire_app, clean_celery_session, override_config):
    raw_record = (b"<record>"
                  b'  <controlfield tag="001">98765</controlfield>'
                  b'  <datafield tag="024" ind1="7" ind2=" ">'
                  b'    <subfield code="9">DOI</subfield>'
                  b'    <subfield code="a">10.1000/a_doi</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="245" ind1=" " ind2=" ">'
                  b'    <subfield code="a">A record to be merged</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="980" ind1=" " ind2=" ">'
                  b'    <subfield code="a">HEP</subfield>'
                  b"  </datafield>"
                  b"</record>")
    migrate_and_insert_record(raw_record)
    db.session.commit()

    record = LiteratureRecord.get_record_by_pid_value("98765")
    assert PersistentIdentifier.get("doi",
                                    "10.1000/a_doi").object_uuid == record.id

    raw_record = (b"<record>"
                  b'  <controlfield tag="001">31415</controlfield>'
                  b'  <datafield tag="024" ind1="7" ind2=" ">'
                  b'    <subfield code="9">DOI</subfield>'
                  b'    <subfield code="a">101000/a_doi</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="245" ind1=" " ind2=" ">'
                  b'    <subfield code="a">A record that was merged</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="980" ind1=" " ind2=" ">'
                  b'    <subfield code="a">HEP</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="981" ind1=" " ind2=" ">'
                  b'    <subfield code="a">98765</subfield>'
                  b"  </datafield>"
                  b"</record>")
    new_config = {"FEATURE_FLAG_ENABLE_REDIRECTION_OF_PIDS": False}
    with override_config(**new_config):
        migrate_and_insert_record(raw_record)
        db.session.commit()

    new_pid = PersistentIdentifier.query.filter_by(
        pid_type="lit", pid_value="31415").one_or_none()
    assert new_pid
    old_pid = PersistentIdentifier.query.filter_by(
        pid_type="lit", pid_value="98765").one_or_none()
    old_record = LiteratureRecord.get_record_by_pid_value(98765)

    assert old_pid.status == PIDStatus.DELETED
    assert old_record["deleted"] is True
def test_migrate_and_insert_record_other_exception(base_app, db, es):
    raw_record = (b"<record>"
                  b'  <controlfield tag="001">12345</controlfield>'
                  b'  <datafield tag="980" ind1=" " ind2=" ">'
                  b'    <subfield code="a">HEP</subfield>'
                  b"  </datafield>"
                  b"</record>")
    migrate_and_insert_record(raw_record)

    prod_record = LegacyRecordsMirror.query.filter(
        LegacyRecordsMirror.recid == 12345).one()
    assert prod_record.valid is False
    assert prod_record.marcxml == raw_record
Example #5
0
def test_migrate_and_insert_record_pidstore_error(inspire_app):
    raw_record = (
        b"<record>"
        b'  <controlfield tag="001">12345</controlfield>'
        b'  <datafield tag="024" ind1="7" ind2=" ">'
        b'    <subfield code="9">DOI</subfield>'
        b'    <subfield code="a">10.1000/some_doi</subfield>'
        b"  </datafield>"
        b'  <datafield tag="245" ind1=" " ind2=" ">'
        b'    <subfield code="a">On the validity of INSPIRE records</subfield>'
        b"  </datafield>"
        b'  <datafield tag="980" ind1=" " ind2=" ">'
        b'    <subfield code="a">HEP</subfield>'
        b"  </datafield>"
        b"</record>"
    )

    migrate_and_insert_record(raw_record)

    prod_record = LegacyRecordsMirror.query.filter(
        LegacyRecordsMirror.recid == 12345
    ).one()
    assert prod_record.valid is True

    raw_record_with_same_doi = (
        b"<record>"
        b'  <controlfield tag="001">98765</controlfield>'
        b'  <datafield tag="024" ind1="7" ind2=" ">'
        b'    <subfield code="9">DOI</subfield>'
        b'    <subfield code="a">10.1000/some_doi</subfield>'
        b"  </datafield>"
        b'  <datafield tag="245" ind1=" " ind2=" ">'
        b'    <subfield code="a">On the validity of INSPIRE records</subfield>'
        b"  </datafield>"
        b'  <datafield tag="980" ind1=" " ind2=" ">'
        b'    <subfield code="a">HEP</subfield>'
        b"  </datafield>"
        b"</record>"
    )

    migrate_and_insert_record(raw_record_with_same_doi)

    prod_record = LegacyRecordsMirror.query.filter(
        LegacyRecordsMirror.recid == 98765
    ).one()
    assert prod_record.valid is False
    assert prod_record.marcxml == raw_record_with_same_doi
    assert "pid_value" in prod_record.error
def test_migrate_and_insert_record_dojson_error(inspire_app):
    raw_record = (b"<record>"
                  b'  <controlfield tag="001">12345</controlfield>'
                  b'  <datafield tag="260" ind1=" " ind2=" ">'
                  b'    <subfield code="c">Definitely not a date</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="980" ind1=" " ind2=" ">'
                  b'    <subfield code="a">HEP</subfield>'
                  b"  </datafield>"
                  b"</record>")

    migrate_and_insert_record(raw_record)

    prod_record = LegacyRecordsMirror.query.filter(
        LegacyRecordsMirror.recid == 12345).one()
    assert prod_record.valid is False
    assert prod_record.marcxml == raw_record
def test_migrate_and_insert_record_valid_record(inspire_app):
    raw_record = (
        b"<record>"
        b'  <controlfield tag="001">12345</controlfield>'
        b'  <datafield tag="245" ind1=" " ind2=" ">'
        b'    <subfield code="a">On the validity of INSPIRE records</subfield>'
        b"  </datafield>"
        b'  <datafield tag="980" ind1=" " ind2=" ">'
        b'    <subfield code="a">HEP</subfield>'
        b"  </datafield>"
        b"</record>")

    migrate_and_insert_record(raw_record)

    prod_record = LegacyRecordsMirror.query.filter(
        LegacyRecordsMirror.recid == 12345).one()
    assert prod_record.valid is True
    assert prod_record.marcxml == raw_record
def test_migrate_and_insert_record_blacklisted_pid(inspire_app):
    raw_record = (b"<record>"
                  b'  <controlfield tag="001">12345</controlfield>'
                  b'  <datafield tag="980" ind1=" " ind2=" ">'
                  b'    <subfield code="a">HEP</subfield>'
                  b"  </datafield>"
                  b"</record>")

    config = {"MIGRATION_PID_TYPE_BLACKLIST": ["lit"]}
    with patch.dict(current_app.config, config):
        migrate_and_insert_record(raw_record)

        with pytest.raises(PIDDoesNotExistError):
            LiteratureRecord.get_record_by_pid_value("12345")

        prod_record = LegacyRecordsMirror.query.filter(
            LegacyRecordsMirror.recid == 12345).one()
        assert prod_record.valid is False
Example #9
0
def test_migrate_record_from_miror_steals_pids_from_deleted_records(inspire_app):
    raw_record = (
        b"<record>"
        b'  <controlfield tag="001">98765</controlfield>'
        b'  <datafield tag="024" ind1="7" ind2=" ">'
        b'    <subfield code="9">DOI</subfield>'
        b'    <subfield code="a">10.1000/a_doi</subfield>'
        b"  </datafield>"
        b'  <datafield tag="245" ind1=" " ind2=" ">'
        b'    <subfield code="a">A record to be merged</subfield>'
        b"  </datafield>"
        b'  <datafield tag="980" ind1=" " ind2=" ">'
        b'    <subfield code="a">HEP</subfield>'
        b"  </datafield>"
        b"</record>"
    )
    migrate_and_insert_record(raw_record)
    record = LiteratureRecord.get_record_by_pid_value("98765")
    assert PersistentIdentifier.get("doi", "10.1000/a_doi").object_uuid == record.id

    raw_record = (
        b"<record>"
        b'  <controlfield tag="001">31415</controlfield>'
        b'  <datafield tag="024" ind1="7" ind2=" ">'
        b'    <subfield code="9">DOI</subfield>'
        b'    <subfield code="a">10.1000/a_doi</subfield>'
        b"  </datafield>"
        b'  <datafield tag="245" ind1=" " ind2=" ">'
        b'    <subfield code="a">A record that was merged</subfield>'
        b"  </datafield>"
        b'  <datafield tag="980" ind1=" " ind2=" ">'
        b'    <subfield code="a">HEP</subfield>'
        b"  </datafield>"
        b'  <datafield tag="981" ind1=" " ind2=" ">'
        b'    <subfield code="a">98765</subfield>'
        b"  </datafield>"
        b"</record>"
    )
    migrate_and_insert_record(raw_record)
    assert LiteratureRecord.get_record_by_pid_value("98765")
    merged_record = LiteratureRecord.get_record_by_pid_value("31415")
    assert (
        PersistentIdentifier.get("doi", "10.1000/a_doi").object_uuid == merged_record.id
    )
Example #10
0
def test_orcid_push_triggered_on_create_record_with_allow_push(
    mock_orcid_push_task,
    inspire_app,
    raw_record,
    user_with_permission,
    enable_orcid_push_feature,
):
    migrate_and_insert_record(raw_record)

    expected_kwargs = {
        "kwargs": {
            "orcid": user_with_permission["orcid"],
            "rec_id": 1608652,
            "oauth_token": user_with_permission["token"],
            "kwargs_to_pusher": {
                "record_db_version": mock.ANY
            },
        }
    }

    mock_orcid_push_task.assert_called_once_with(**expected_kwargs)
Example #11
0
def test_orcid_push_not_triggered_on_create_record_no_feat_flag(
        mocked_Task, inspire_app, raw_record, user_with_permission):
    migrate_and_insert_record(raw_record)

    mocked_Task.assert_not_called()
Example #12
0
def test_orcid_push_not_triggered_on_create_record_without_token(
        mock_orcid_push_task, inspire_app, raw_record, user_without_token):
    migrate_and_insert_record(raw_record)

    mock_orcid_push_task.assert_not_called()
Example #13
0
def record(raw_record):
    with mock.patch("inspirehep.orcid.api._send_push_task") as mock_orcid_push:
        mock_orcid_push.return_value = mock_orcid_push
        _record = migrate_and_insert_record(raw_record)

    return _record
def test_migrate_record_from_miror_do_not_leaves_deleted_pids_when_migration_fails(
        inspire_app, clean_celery_session):
    raw_record = (b"<record>"
                  b'  <controlfield tag="001">98765</controlfield>'
                  b'  <datafield tag="024" ind1="7" ind2=" ">'
                  b'    <subfield code="9">DOI</subfield>'
                  b'    <subfield code="a">10.1000/a_doi</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="245" ind1=" " ind2=" ">'
                  b'    <subfield code="a">A record to be merged</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="980" ind1=" " ind2=" ">'
                  b'    <subfield code="a">HEP</subfield>'
                  b"  </datafield>"
                  b"</record>")
    migrate_and_insert_record(raw_record)
    db.session.commit()

    record = LiteratureRecord.get_record_by_pid_value("98765")
    assert PersistentIdentifier.get("doi",
                                    "10.1000/a_doi").object_uuid == record.id

    raw_record = (b"<record>"
                  b'  <controlfield tag="001">31415</controlfield>'
                  b'  <datafield tag="024" ind1="7" ind2=" ">'
                  b'    <subfield code="9">DOI</subfield>'
                  b'    <subfield code="a">101000/a_doi</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="245" ind1=" " ind2=" ">'
                  b'    <subfield code="a">A record that was merged</subfield>'
                  b"  </datafield>"
                  b'  <datafield tag="980" ind1=" " ind2=" ">'
                  b'    <subfield code="a">HEP</subfield>'
                  b"  </datafield>"
                  b"</record>")
    migrate_and_insert_record(raw_record)
    db.session.commit()

    new_pid = PersistentIdentifier.query.filter_by(
        pid_type="lit", pid_value="31415").one_or_none()
    assert new_pid

    update_raw_record = (
        b"<record>"
        b'  <controlfield tag="001">31415</controlfield>'
        b'  <datafield tag="024" ind1="7" ind2=" ">'
        b'    <subfield code="9">DOI</subfield>'
        b'    <subfield code="a">101000/a_doi</subfield>'
        b"  </datafield>"
        b'  <datafield tag="245" ind1=" " ind2=" ">'
        b'    <subfield code="a">A record that was merged</subfield>'
        b"  </datafield>"
        b'  <datafield tag="980" ind1=" " ind2=" ">'
        b'    <subfield code="a">HEPX</subfield>'
        b"  </datafield>"
        b'  <datafield tag="981" ind1=" " ind2=" ">'
        b'    <subfield code="a">98765</subfield>'
        b"  </datafield>"
        b"</record>")
    migrate_and_insert_record(update_raw_record)
    db.session.commit()

    old_pid = PersistentIdentifier.query.filter_by(
        pid_type="lit", pid_value="98765").one_or_none()
    assert old_pid.status == PIDStatus.REGISTERED
Example #15
0
def test_orcid_push_not_triggered_on_create_record_without_allow_push(
        mock_orcid_push_task, base_app, db, es, raw_record,
        user_without_permission):
    migrate_and_insert_record(raw_record)

    mock_orcid_push_task.assert_not_called()