Example #1
0
def FIXME_test_handle_payload(app, db, tester_id, remote_token):
    from invenio_webhooks.models import Event

    httpretty.enable()
    extra_data = remote_token.remote_account.extra_data
    assert 'auser/repo-1' in extra_data['repos']
    assert 'auser/repo-2' in extra_data['repos']

    assert len(extra_data['repos']['auser/repo-1']['depositions']) == 0
    assert len(extra_data['repos']['auser/repo-2']['depositions']) == 0

    event = Event(receiver_id='github',
                  user_id=tester_id,
                  payload=fixtures.PAYLOAD('auser', 'repo-1'))
    db.session.add(event)
    db.session.commit()

    event.process()

    db.session.expire(remote_token.remote_account)
    extra_data = self.remote_token.remote_account.extra_data
    assert len(extra_data['repos']['auser/repo-1']['depositions']) == 1
    assert len(extra_data['repos']['auser/repo-2']['depositions']) == 0

    dep = extra_data['repos']['auser/repo-1']['depositions'][0]

    assert dep['doi'].endswith(six.text_type(dep['record_id']))
    assert dep['errors'] is None
    assert dep['github_ref'] == "v1.0"
Example #2
0
def payload_debug(event_state):
    """"Debug a GitHub payload."""
    res = dict()
    try:
        e = Event()
        e.__setstate__(event_state)
        res['event'] = e

        current_app.try_trigger_before_first_request_functions()

        account = get_account(user_id=e.user_id)
        res['account'] = account

        gh = get_api(user_id=e.user_id)
        res['gh'] = gh

        access_token = ProviderToken.query.filter_by(
            id=account.extra_data["tokens"]["internal"]).first().access_token
        res['access_token'] = access_token

        res['is_valid_sender'] = is_valid_sender(account.extra_data, e.payload)

        res['metadata'] = extract_metadata(gh, e.payload)

        res['files'] = extract_files(e.payload, account.tokens[0].access_token)
    finally:
        pass
    return res
Example #3
0
def test_extract_metadata(app, db, tester_id, remote_token, github_api):

    Repository.enable(tester_id, github_id=2, name='repo-2', hook=1234)
    event = Event(
        receiver_id='github',
        user_id=tester_id,
        payload=fixtures.PAYLOAD('auser', 'repo-2', 2, tag='v1.0'),
    )
    release = Release.create(event)
    gh = GitHubRelease(release)
    metadata = gh.metadata

    assert metadata['upload_type'] == 'dataset'
    assert metadata['license'] == 'mit-license'
    assert len(metadata['creators']) == 2
def test_get_tasks_status_by_task():
    """Test get tasks status by task."""
    # simulate a "celery cache empty" creating an empty result
    AsyncResult = namedtuple('AsyncResult', ['result', 'status'])
    lost_result = AsyncResult(None, states.PENDING)
    # and: event -> receiver -> lost result
    Event = namedtuple('Event', ['receiver'])
    receiver = mock.MagicMock()
    receiver.has_result = mock.MagicMock(return_value=True)
    receiver._raw_info = mock.MagicMock(
        return_value={'task_trascode': lost_result})
    event = Event(receiver)
    # build the current state if the previous value saved on db is SUCCESS
    computed_states = get_tasks_status_by_task(
        events=[event], statuses={'task_trascode': states.SUCCESS})
    assert computed_states == {'task_trascode': states.SUCCESS}
Example #5
0
def test_serializer():
    """Test result serializer on event."""
    event = Event()
    event.response = {}

    result = chain(simple_add.s(1, 2),
                   group(simple_add.s(3), simple_add.s(4),
                         failing_task.s())).apply_async()

    CeleryAsyncReceiver._serialize_result(event=event, result=result)
    deserialized_result = CeleryAsyncReceiver._deserialize_result(event=event)

    assert deserialized_result.id == result.id
    assert deserialized_result.parent.id == result.parent.id
    assert deserialized_result.children[0].id == result.children[0].id
    assert deserialized_result.children[1].id == result.children[1].id
    assert deserialized_result.children[2].id == result.children[2].id
Example #6
0
def test_handle_payload(app, db, location, tester_id, remote_token,
                        github_api):

    from invenio_webhooks.models import Event

    extra_data = remote_token.remote_account.extra_data

    assert '1' in extra_data['repos']
    assert 'repo-1' in extra_data['repos']['1']['full_name']
    assert '2' in extra_data['repos']
    assert 'repo-2' in extra_data['repos']['2']['full_name']

    # Create the repository that will make the release

    with db.session.begin_nested():
        Repository.enable(tester_id, github_id=1, name='repo-1', hook=1234)
        event = Event(receiver_id='github',
                      user_id=tester_id,
                      payload=fixtures.PAYLOAD('auser', 'repo-1', 1))
        db.session.add(event)

    with patch('invenio_deposit.api.Deposit.indexer'):
        event.process()

        repo_1 = Repository.query.filter_by(name='repo-1', github_id=1).first()
        assert repo_1.releases.count() == 1

        release = repo_1.releases.first()
        assert release.status == ReleaseStatus.PUBLISHED
        assert release.errors is None
        assert release.tag == 'v1.0'
        assert release.record is not None
        assert release.record.get('control_number') == '1'
        record_files = release.record.get('_files')
        assert len(record_files) == 1
        assert record_files[0]['size'] > 0

        bucket = Bucket.get(record_files[0]['bucket'])
        assert bucket is not None
        assert len(bucket.objects) == 1
        assert bucket.objects[0].key == 'auser/repo-1-v1.0.zip'