<!--

Copyright 2017-2018 Lars Wirzenius

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

-->

# Scenario step implementations (local and remote instances)

## Data file creation

    IMPLEMENTS WHEN user creates a blob named (\S+) with random data
    filename = get_next_match()
    n = 16
    blob = os.urandom(n)
    write(filename, blob)

## HTTP requests of various kinds

    IMPLEMENTS WHEN (\S+) makes request GET (\S+)
    user = get_next_match()
    path = get_next_match()
    token = get_token(user)
    url = V['url']
    http(V, get, url + path, token=token)

    IMPLEMENTS WHEN (\S+) retrieves (\S+) from artifact store
    user = get_next_match()
    path = get_next_match()
    token = get_token(user)
    url = V['bsurl']
    http(V, get_blob, url + path, token=token)

    IMPLEMENTS WHEN (\S+) makes request GET (\S+) with an invalid token
    user = get_next_match()
    path = get_next_match()
    token = get_token(user)
    url = V['url']
    http(V, get, url + path, token='invalid')

    IMPLEMENTS WHEN (\S+) makes request POST (\S+) with a valid token and body (.+)
    user = get_next_match()
    path = get_next_match()
    body = get_next_match()
    token = get_token(user)
    url = V['url']
    http(V, post, url + path, body=body, token=token)

    IMPLEMENTS WHEN (\S+) makes request POST (\S+) with an invalid token and body (.+)
    user = get_next_match()
    path = get_next_match()
    body = get_next_match()
    token = get_token(user)
    url = V['url']
    http(V, post, url + path, body=body, token='invalid')

    IMPLEMENTS WHEN (\S+) makes request PUT (\S+) with a valid token and body (.+)
    user = get_next_match()
    path = get_next_match()
    body = get_next_match()
    token = get_token(user)
    url = V['url']
    http(V, put, url + path, body=body, token=token)

    IMPLEMENTS WHEN (\S+) sends blob (\S+) to artifact store as (\S+)
    user = get_next_match()
    filename = get_next_match()
    path = get_next_match()
    body = cat(filename)
    token = get_token(user)
    url = V['bsurl']
    http(V, put_blob, url + path, body=body, token=token)

    IMPLEMENTS WHEN (\S+) makes request PUT (\S+) with an invalid token
    user = get_next_match()
    path = get_next_match()
    body = '{}'
    token = get_token(user)
    url = V['url']
    http(V, put, url + path, body=body, token='invalid')

    IMPLEMENTS WHEN (\S+) makes request DELETE (\S+)
    user = get_next_match()
    path = get_next_match()
    token = get_token(user)
    url = V['url']
    http(V, delete, url + path, token=token)

## HTTP response inspection

    IMPLEMENTS THEN result has status code (\d+)
    expected = int(get_next_match())
    assertEqual(expected, V['status_code'])

    IMPLEMENTS THEN body matches (.+)
    expected_text = get_next_match()
    expected = json.loads(expected_text)
    actual = json.loads(V['body'])
    print 'expected'
    json.dump(expected, sys.stdout, indent=4, sort_keys=True)
    print
    print 'actual'
    json.dump(actual, sys.stdout, indent=4, sort_keys=True)
    print
    diff = dict_diff(expected, actual)
    if diff is not None:
        print(diff)
        assert 0

    IMPLEMENTS THEN body text contains "(.*)"
    pattern = unescape(get_next_match())
    text = V['body']
    print 'pattern:', repr(pattern)
    print 'text:', text
    assertTrue(pattern in text)

    IMPLEMENTS THEN body is the same as the blob (\S+)
    filename = get_next_match()
    blob = cat(filename)
    body = V['body']
    assertEqual(body, blob)

    IMPLEMENTS THEN version in body matches version from setup.py
    body = V['body']
    obj = json.loads(body)
    actual = obj['version']
    setup_py = os.path.join(srcdir, 'setup.py')
    wanted = cliapp.runcmd(['python3', setup_py, '--version']).strip()
    assertTrue(wanted.startswith(actual))

    IMPLEMENTS THEN result has header (\S+): (\S+)
    name = get_next_match()
    value = get_next_match()
    headers = V['headers']
    assertEqual(headers[name].lower(), value.lower())

    IMPLEMENTS THEN result is step (.+)
    step = json.loads(get_next_match())
    print('expected step', step)
    body = json.loads(V['body'])
    print('actual body', body)
    actual_step = body['step']
    print('actual step', actual_step)
    diff = dict_diff(step, actual_step)
    print('diff', diff)
    assertEqual(diff, None)

    IMPLEMENTS WHEN (\S+) requests list of builds
    user = get_next_match()
    token = get_token(user)
    url = V['url']
    path = '/builds'
    http(V, get, url + path, token=token)

    IMPLEMENTS THEN the list of builds is (.+)
    expected = set(json.loads(get_next_match()))
    print('expected', expected)
    body = json.loads(V['body'])['builds']
    print('body', body)
    builds = set(build['build_id'] for build in body)
    assertEqual(builds, expected)