Exemplo n.º 1
0
def test_multiple_event_update_second_fails(api_client, minimal_event_dict,
                                            user):
    api_client.force_authenticate(user)
    minimal_event_dict_2 = deepcopy(minimal_event_dict)
    minimal_event_dict_2['name']['fi'] = 'testaus_2'

    # create events first
    resp = create_with_post(api_client, minimal_event_dict)
    minimal_event_dict['id'] = resp.data['id']
    resp = create_with_post(api_client, minimal_event_dict_2)
    minimal_event_dict_2['id'] = resp.data['id']

    minimal_event_dict['name']['fi'] = 'updated_name'
    minimal_event_dict_2.pop(
        'name')  # name is required, so the event update event should fail

    response = api_client.put(reverse('event-list'),
                              [minimal_event_dict, minimal_event_dict_2],
                              format='json')
    assert response.status_code == 400
    assert 'name' in response.data[1]

    event_names = set(Event.objects.values_list('name_fi', flat=True))

    # verify that first event isn't updated either
    assert event_names == {'testaus', 'testaus_2'}
Exemplo n.º 2
0
def test_multiple_event_update_non_allowed_data_fails(api_client,
                                                      minimal_event_dict,
                                                      other_data_source, user):
    api_client.force_authenticate(user)
    minimal_event_dict_2 = deepcopy(minimal_event_dict)
    minimal_event_dict_2['name']['fi'] = 'testaus_2'

    # create events first
    resp = create_with_post(api_client, minimal_event_dict)
    minimal_event_dict['id'] = resp.data['id']
    resp = create_with_post(api_client, minimal_event_dict_2)
    minimal_event_dict_2['id'] = resp.data['id']

    minimal_event_dict['name']['fi'] = 'updated_name'
    minimal_event_dict_2[
        'data_source'] = other_data_source.id  # data source not allowed

    response = api_client.put(reverse('event-list'),
                              [minimal_event_dict, minimal_event_dict_2],
                              format='json')
    print(response.data)
    assert response.status_code == 400
    assert 'data_source' in response.data

    event_names = set(Event.objects.values_list('name_fi', flat=True))

    # verify that first event isn't updated either
    assert event_names == {'testaus', 'testaus_2'}
Exemplo n.º 3
0
def test__location_n_events_updated(api_client, minimal_event_dict, user,
                                    data_source, other_data_source, place2):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, minimal_event_dict)
    assert_event_data_is_equal(minimal_event_dict, response.data)
    call_command('update_n_events')
    assert Place.objects.get(id=data_source.id +
                             ':test_location').n_events == 1
    data2 = response.data
    print('got the post response')
    print(data2)

    # change the location
    event_id = data2.pop('@id')
    data2['location'] = {'@id': location_id(place2)}
    response2 = update_with_put(api_client, event_id, data2)
    print('got the put response')
    print(response2.data)
    call_command('update_n_events')
    assert Place.objects.get(id=data_source.id +
                             ':test_location').n_events == 0
    assert Place.objects.get(id=other_data_source.id +
                             ':test_location_2').n_events == 1
Exemplo n.º 4
0
def test__keyword_n_events_updated(api_client, minimal_event_dict, user,
                                   data_source, organization, make_keyword_id):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, minimal_event_dict)
    assert_event_data_is_equal(minimal_event_dict, response.data)
    call_command('update_n_events')
    assert Keyword.objects.get(id=data_source.id + ':test').n_events == 1
    data2 = response.data
    print('got the post response')
    print(data2)

    # change the keyword and add an audience
    event_id = data2.pop('@id')
    data2['keywords'] = [{
        '@id':
        make_keyword_id(data_source, organization, 'test2')
    }]
    data2['audience'] = [{
        '@id':
        make_keyword_id(data_source, organization, 'test3')
    }]
    response2 = update_with_put(api_client, event_id, data2)
    print('got the put response')
    print(response2.data)
    call_command('update_n_events')
    assert Keyword.objects.get(id=data_source.id + ':test').n_events == 0
    assert Keyword.objects.get(id=data_source.id + ':test2').n_events == 1
    assert Keyword.objects.get(id=data_source.id + ':test3').n_events == 1
Exemplo n.º 5
0
def test__update_an_event_with_put(api_client, complex_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # dummy inputs
    TEXT = 'text updated'
    URL = "http://localhost"

    # set up updates
    data2 = response.data

    for key in ('name', ):
        for lang in ('fi', 'en', 'sv'):
            if lang in data2[key]:
                data2[key][lang] = '%s updated' % data2[key][lang]

    data2['offers'] = [
        {
            "is_free": False,
            "price": {"en": TEXT, "sv": TEXT, "fi": TEXT},
            "description": {"en": TEXT, "fi": TEXT},
            "info_url": {"en": URL, "sv": URL, "fi": URL}
        }
    ]
    data2['keywords'] = data2['keywords'][:1]
    data2['in_language'] = data2['in_language'][:2]

    # store updates
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 6
0
def test__reschedule_a_cancelled_event_with_put(api_client, complex_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # mark the event cancelled
    data2 = response.data
    data2['event_status'] = 'EventCancelled'

    # update the event
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend cancelled the event
    data2['event_status'] = 'EventCancelled'
    assert_event_data_is_equal(data2, response2.data)

    # create a new datetime and remove the cancelled status
    new_datetime = (timezone.now() + timedelta(days=3)).isoformat()
    data3 = response2.data
    data3['start_time'] = new_datetime
    data3['end_time'] = new_datetime
    data3.pop('event_status')

    # update the event
    event_id = data3.pop('@id')
    response3 = update_with_put(api_client, event_id, data3)

    # assert backend rescheduled the event
    data3['event_status'] = 'EventRescheduled'
    assert_event_data_is_equal(data3, response3.data)
Exemplo n.º 7
0
def test__update_minimal_event_with_autopopulated_fields_with_put(
        api_client, minimal_event_dict, user, organization):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, minimal_event_dict)
    data = response.data

    assert_event_data_is_equal(minimal_event_dict, data)
    event_id = data['@id']

    response2 = update_with_put(api_client, event_id, minimal_event_dict)
    assert_event_data_is_equal(data, response2.data)
    event = Event.objects.get(id=data['id'])
    assert event.created_by == user
    assert event.last_modified_by == user
    assert event.created_time is not None
    assert event.last_modified_time is not None
    assert event.data_source.id == settings.SYSTEM_DATA_SOURCE_ID
    assert event.publisher == organization
    # events are automatically marked as ending at midnight, local time
    expected_end_time = (timezone.localtime(event.start_time).replace(
        hour=0, minute=0, second=0, microsecond=0).astimezone(pytz.utc) +
                         timedelta(days=1))
    assert event.end_time == expected_end_time
    assert event.has_end_time is False
Exemplo n.º 8
0
def test__update_an_event_with_put(api_client, complex_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # dummy inputs
    TEXT = 'text updated'
    URL = "http://localhost"

    # set up updates
    data2 = response.data

    for key in ('name', ):
        for lang in ('fi', 'en', 'sv'):
            if lang in data2[key]:
                data2[key][lang] = '%s updated' % data2[key][lang]

    data2['offers'] = [
        {
            "is_free": False,
            "price": {"en": TEXT, "sv": TEXT, "fi": TEXT},
            "description": {"en": TEXT, "fi": TEXT},
            "info_url": {"en": URL, "sv": URL, "fi": URL}
        }
    ]
    data2['keywords'] = data2['keywords'][:1]
    data2['in_language'] = data2['in_language'][:2]

    # store updates
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 9
0
def test__cancel_a_postponed_event_with_put(api_client, complex_event_dict,
                                            user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # remove the start_time
    data2 = response.data
    data2['start_time'] = None

    # update the event
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend postponed the event
    data2['event_status'] = 'EventPostponed'
    assert_event_data_is_equal(data2, response2.data)

    # mark the event cancelled
    data2 = response.data
    data2['event_status'] = 'EventCancelled'

    # update the event
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend cancelled the event
    data2['event_status'] = 'EventCancelled'
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 10
0
def test__reschedule_a_cancelled_event_with_put(api_client, complex_event_dict,
                                                user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # mark the event cancelled
    data2 = response.data
    data2['event_status'] = 'EventCancelled'

    # update the event
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend cancelled the event
    data2['event_status'] = 'EventCancelled'
    assert_event_data_is_equal(data2, response2.data)

    # create a new datetime and remove the cancelled status
    new_datetime = (timezone.now() + timedelta(days=3)).isoformat().replace(
        '+00:00', 'Z')
    data3 = response2.data
    data3['start_time'] = new_datetime
    data3['end_time'] = new_datetime
    data3.pop('event_status')

    # update the event
    event_id = data3.pop('@id')
    response3 = update_with_put(api_client, event_id, data3)

    # assert backend rescheduled the event
    data3['event_status'] = 'EventRescheduled'
    assert_event_data_is_equal(data3, response3.data)
Exemplo n.º 11
0
def test__cancel_a_postponed_event_with_put(api_client, complex_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # remove the start_time
    data2 = response.data
    data2['start_time'] = None

    # update the event
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend postponed the event
    data2['event_status'] = 'EventPostponed'
    assert_event_data_is_equal(data2, response2.data)

    # mark the event cancelled
    data2 = response.data
    data2['event_status'] = 'EventCancelled'

    # update the event
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend cancelled the event
    data2['event_status'] = 'EventCancelled'
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 12
0
def test_response_contains_replacing_event(api_client, event, minimal_event_dict, user):
    api_client.force_authenticate(user)

    response = create_with_post(api_client, minimal_event_dict)

    pk = response.data['id']
    minimal_event_dict['replaced_by'] = event.pk
    response2 = api_client.put(reverse('event-detail', kwargs={'pk': pk}), minimal_event_dict, format='json')
    assert response2.status_code == 200
    assert response2.data['id'] == event.pk
Exemplo n.º 13
0
def test_multiple_event_update(api_client, minimal_event_dict, user):
    api_client.force_authenticate(user)
    minimal_event_dict_2 = deepcopy(minimal_event_dict)
    minimal_event_dict_2['name']['fi'] = 'testing_2'

    # create events first
    resp = create_with_post(api_client, minimal_event_dict)
    minimal_event_dict['id'] = resp.data['id']
    resp = create_with_post(api_client, minimal_event_dict_2)
    minimal_event_dict_2['id'] = resp.data['id']

    minimal_event_dict['name']['fi'] = 'updated_name'
    minimal_event_dict_2['name']['fi'] = 'updated_name_2'

    response = api_client.put(reverse('event-list'), [minimal_event_dict, minimal_event_dict_2], format='json')
    assert response.status_code == 200

    event_names = set(Event.objects.values_list('name_fi', flat=True))

    assert event_names == {'updated_name', 'updated_name_2'}
Exemplo n.º 14
0
def test_multiple_event_update(api_client, minimal_event_dict, user):
    api_client.force_authenticate(user)
    minimal_event_dict_2 = deepcopy(minimal_event_dict)
    minimal_event_dict_2['name']['fi'] = 'testing_2'

    # create events first
    resp = create_with_post(api_client, minimal_event_dict)
    minimal_event_dict['id'] = resp.data['id']
    resp = create_with_post(api_client, minimal_event_dict_2)
    minimal_event_dict_2['id'] = resp.data['id']

    minimal_event_dict['name']['fi'] = 'updated_name'
    minimal_event_dict_2['name']['fi'] = 'updated_name_2'

    response = api_client.put(reverse('event-list'), [minimal_event_dict, minimal_event_dict_2], format='json')
    assert response.status_code == 200

    event_names = set(Event.objects.values_list('name_fi', flat=True))

    assert event_names == {'updated_name', 'updated_name_2'}
Exemplo n.º 15
0
def test__postpone_an_event_with_put(api_client, complex_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # remove the start_time
    data2 = response.data
    data2['start_time'] = None

    # update the event
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend postponed the event
    data2['event_status'] = 'EventPostponed'
    assert_event_data_is_equal(data2, response2.data)

    # try to cancel marking as postponed
    data2 = response2.data
    data2['event_status'] = 'EventScheduled'
    response3 = api_client.put(event_id, data2, format='json')

    # assert the event does not revert back to scheduled
    assert response3.status_code == 400
    assert 'event_status' in response2.data

    # reschedule and try to cancel marking
    new_datetime = (timezone.now() + timedelta(days=3)).isoformat().replace(
        '+00:00', 'Z')
    data2['start_time'] = new_datetime
    data2['end_time'] = new_datetime
    data2['event_status'] = 'EventScheduled'
    response3 = api_client.put(event_id, data2, format='json')

    # assert the event does not revert back to scheduled
    assert response3.status_code == 400
    assert 'event_status' in response3.data

    # reschedule, but do not try to cancel marking
    data2 = response2.data
    new_datetime = (timezone.now() + timedelta(days=3)).isoformat().replace(
        '+00:00', 'Z')
    data2['start_time'] = new_datetime
    data2['end_time'] = new_datetime
    data2.pop('event_status')
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert the event is marked rescheduled
    data2['event_status'] = 'EventRescheduled'
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 16
0
def test_multiple_event_update_second_fails(api_client, minimal_event_dict, user):
    api_client.force_authenticate(user)
    minimal_event_dict_2 = deepcopy(minimal_event_dict)
    minimal_event_dict_2['name']['fi'] = 'testing_2'

    # create events first
    resp = create_with_post(api_client, minimal_event_dict)
    minimal_event_dict['id'] = resp.data['id']
    resp = create_with_post(api_client, minimal_event_dict_2)
    minimal_event_dict_2['id'] = resp.data['id']

    minimal_event_dict['name']['fi'] = 'updated_name'
    minimal_event_dict_2.pop('name')  # name is required, so the event update event should fail

    response = api_client.put(reverse('event-list'), [minimal_event_dict, minimal_event_dict_2], format='json')
    assert response.status_code == 400
    assert 'name' in response.data[1]

    event_names = set(Event.objects.values_list('name_fi', flat=True))

    # verify that first event isn't updated either
    assert event_names == {'testing', 'testing_2'}
Exemplo n.º 17
0
def test__postpone_an_event_with_put(api_client, complex_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # remove the start_time
    data2 = response.data
    data2['start_time'] = None

    # update the event
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend postponed the event
    data2['event_status'] = 'EventPostponed'
    assert_event_data_is_equal(data2, response2.data)

    # try to cancel marking as postponed
    data2 = response2.data
    data2['event_status'] = 'EventScheduled'
    response3 = api_client.put(event_id, data2, format='json')

    # assert the event does not revert back to scheduled
    assert response3.status_code == 400
    assert 'event_status' in response2.data

    # reschedule and try to cancel marking
    new_datetime = (timezone.now() + timedelta(days=3)).isoformat()
    data2['start_time'] = new_datetime
    data2['end_time'] = new_datetime
    data2['event_status'] = 'EventScheduled'
    response3 = api_client.put(event_id, data2, format='json')

    # assert the event does not revert back to scheduled
    assert response3.status_code == 400
    assert 'event_status' in response3.data

    # reschedule, but do not try to cancel marking
    data2 = response2.data
    new_datetime = (timezone.now() + timedelta(days=3)).isoformat()
    data2['start_time'] = new_datetime
    data2['end_time'] = new_datetime
    data2.pop('event_status')
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert the event is marked rescheduled
    data2['event_status'] = 'EventRescheduled'
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 18
0
def test__reschedule_an_event_with_put(api_client, complex_event_dict, user):

    # create an event
    #api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # create a new datetime
    new_datetime = (timezone.now() + timedelta(days=3)).isoformat().replace(
        '+00:00', 'Z')
    data2 = response.data
    data2['start_time'] = new_datetime
    data2['end_time'] = new_datetime

    # update the event
    event_id = data2.pop('@id')
    data2['pin'] = '1234a'
    data2.pop('publisher')
    data2.pop('data_source')
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend rescheduled the event
    data2['event_status'] = 'EventRescheduled'
    response2.data.pop('publisher')
    response2.data.pop('data_source')
    assert_event_data_is_equal(data2, response2.data)

    # try to cancel marking as rescheduled
    data2['event_status'] = 'EventScheduled'
    data2['pin'] = '1234a'
    response3 = api_client.put(event_id, data2, format='json')

    # assert the event does not revert back to scheduled
    assert response3.status_code == 400
    assert 'event_status' in response3.data

    # create a new datetime again
    new_datetime = (timezone.now() + timedelta(days=3)).isoformat().replace(
        '+00:00', 'Z')
    data2 = response2.data
    data2['start_time'] = new_datetime
    data2['end_time'] = new_datetime

    # update the event again
    data2['pin'] = '1234a'
    response2 = update_with_put(api_client, event_id, data2)

    # assert the event remains rescheduled
    data2['event_status'] = 'EventRescheduled'
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 19
0
def test__non_editable_fields_at_put(api_client, minimal_event_dict, user,
                                     non_permitted_input, non_permitted_response):
    # create the event first
    api_client.force_authenticate(user)
    response = create_with_post(api_client, minimal_event_dict)
    data2 = response.data
    event_id = data2.pop('@id')

    # try to put non permitted values
    data2.update(non_permitted_input)

    response2 = api_client.put(event_id, data2, format='json')
    assert response2.status_code == non_permitted_response
    if non_permitted_response >= 400:
        # check that there is an error message for the corresponding field
        assert list(non_permitted_input)[0] in response2.data
Exemplo n.º 20
0
def test__non_editable_fields_at_put(api_client, minimal_event_dict, user,
                                     non_permitted_input, non_permitted_response):
    # create the event first
    api_client.force_authenticate(user)
    response = create_with_post(api_client, minimal_event_dict)
    data2 = response.data
    event_id = data2.pop('@id')

    # try to put non permitted values
    data2.update(non_permitted_input)

    response2 = api_client.put(event_id, data2, format='json')
    assert response2.status_code == non_permitted_response
    if non_permitted_response >= 400:
        # check that there is an error message for the corresponding field
        assert list(non_permitted_input)[0] in response2.data
Exemplo n.º 21
0
def test__cannot_update_an_event_without_a_short_description(api_client, minimal_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, minimal_event_dict)
    assert_event_data_is_equal(minimal_event_dict, response.data)
    data2 = response.data

    # delete name
    data2['short_description'] = {'fi': None}
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)
    assert response2.status_code == 400
    assert 'short_description' in response2.data
    data2.pop('short_description')
    response2 = update_with_put(api_client, event_id, data2)
    assert response2.status_code == 400
    assert 'short_description' in response2.data
Exemplo n.º 22
0
def test__apikey_non_editable_fields_at_put(api_client, minimal_event_dict, organization, data_source,
                                            non_permitted_input, non_permitted_response):
    # create the event first
    data_source.owner = organization
    data_source.save()
    response = create_with_post(api_client, minimal_event_dict, data_source)
    data2 = response.data
    event_id = data2.pop('@id')

    # try to put non permitted values
    data2.update(non_permitted_input)

    response2 = api_client.put(event_id, data2, format='json',
                               credentials={'apikey': data_source.api_key})
    assert response2.status_code == non_permitted_response
    if non_permitted_response >= 400:
        # check that there is an error message for the corresponding field
        assert list(non_permitted_input)[0] in response2.data
Exemplo n.º 23
0
def test__update_an_event_with_naive_datetime(api_client, minimal_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, minimal_event_dict)
    assert_event_data_is_equal(minimal_event_dict, response.data)
    data2 = response.data

    # store updates
    event_id = data2.pop('@id')
    data2['start_time'] = (datetime.now() + timedelta(days=1)).isoformat()
    response2 = update_with_put(api_client, event_id, data2)

    # API should have assumed UTC datetime
    data2['start_time'] = pytz.utc.localize(dateutil_parse(data2['start_time'])).isoformat().replace('+00:00', 'Z')
    data2['event_status'] = 'EventRescheduled'

    # assert
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 24
0
def test__cancel_an_event_with_put(api_client, complex_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    response = create_with_post(api_client, complex_event_dict)

    # mark the event cancelled
    data2 = response.data
    data2['event_status'] = 'EventCancelled'

    # cancelling (like deleting) should be allowed even if event is incomplete (external events etc.)
    data2['keywords'] = []
    data2['location'] = None

    # update the event
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)

    # assert backend cancelled the event
    data2['event_status'] = 'EventCancelled'
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 25
0
def test__update_a_draft_with_put(api_client, minimal_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    minimal_event_dict.pop('location')
    minimal_event_dict.pop('keywords')
    minimal_event_dict['publication_status'] = 'draft'
    response = create_with_post(api_client, minimal_event_dict)
    assert_event_data_is_equal(minimal_event_dict, response.data)
    data2 = response.data
    print('got the post response')
    print(data2)

    # store updates
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)
    print('got the put response')
    print(response2.data)

    # assert
    assert_event_data_is_equal(data2, response2.data)
Exemplo n.º 26
0
def test__cannot_update_a_draft_without_a_name(api_client, minimal_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    minimal_event_dict.pop('location')
    minimal_event_dict.pop('keywords')
    minimal_event_dict['publication_status'] = 'draft'
    response = create_with_post(api_client, minimal_event_dict)
    assert_event_data_is_equal(minimal_event_dict, response.data)
    data2 = response.data

    # delete name
    data2['name'] = {'fi': None}
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)
    assert response2.status_code == 400
    assert 'name' in response2.data
    data2.pop('name')
    response2 = update_with_put(api_client, event_id, data2)
    assert response2.status_code == 400
    assert 'name' in response2.data
Exemplo n.º 27
0
def test__update_a_draft_with_put(api_client, minimal_event_dict, user):

    # create an event
    api_client.force_authenticate(user=user)
    minimal_event_dict.pop('location')
    minimal_event_dict.pop('keywords')
    minimal_event_dict['publication_status'] = 'draft'
    response = create_with_post(api_client, minimal_event_dict)
    assert_event_data_is_equal(minimal_event_dict, response.data)
    data2 = response.data
    print('got the post response')
    print(data2)

    # store updates
    event_id = data2.pop('@id')
    response2 = update_with_put(api_client, event_id, data2)
    print('got the put response')
    print(response2.data)

    # assert
    assert_event_data_is_equal(data2, response2.data)