def testDeleteItemUpdatesSize(server, admin, hierarchy):
    resp = server.request(path='/item/%s' % hierarchy.items[0]['_id'], method='DELETE', user=admin)
    assertStatusOk(resp)

    assertNodeSize(hierarchy.folders[0], Folder, 0)
    assertNodeSize(hierarchy.folders[1], Folder, 10)
    assertNodeSize(hierarchy.collections[0], Collection, 10)

def testCustomWebRoot(route, server):
    """
    Tests the ability of plugins to serve their own custom server roots.
    """
    resp = server.request(route)
    assertStatusOk(resp)
    assert resp.json == ['custom REST route']

def testTokenSessionReturnsPassedToken(server, token):
    # If we ask for another token, passing in the first one, we should get
    # the first one back
    resp = server.request(path='/token/session', method='GET', token=token)
    assertStatusOk(resp)
    token2 = resp.json['token']
    assert token == token2

def testDisableApiKeysSetting(server, user):
    errMsg = 'API key functionality is disabled on this instance.'

    resp = server.request('/api_key', method='POST', user=user, params={
        'name': 'test key'
    })
    assertStatusOk(resp)

    # Disable API keys
    Setting().set(SettingKey.API_KEYS, False)

    # Key should still exist
    key = ApiKey().load(resp.json['_id'], force=True, exc=True)

    # No longer possible to authenticate with existing key
    resp = server.request('/api_key/token', method='POST', params={
        'key': key['key']
    })
    assertStatus(resp, 400)
    assert resp.json['message'] == errMsg

    # No longer possible to create new keys
    resp = server.request('/api_key', method='POST', user=user, params={
        'name': 'should not work'
    })
    assertStatus(resp, 400)
    assert resp.json['message'] == errMsg

    # Still possible to delete key
    resp = server.request('/api_key/%s' % key['_id'], method='DELETE', user=user)
    assertStatusOk(resp)
    assert ApiKey().load(key['_id'], force=True) is None

def test_get_cjson(server, calculation, user):

    assert '_id' in calculation
    assert 'moleculeId' in calculation
    calc_id = str(calculation['_id'])
    calc_molecule_id = str(calculation['moleculeId'])

    # Get the cjson for the calculation
    r = server.request(
        '/calculations/%s/cjson' %
        calc_id, method='GET', user=user)
    assertStatusOk(r)

    cjson = json.loads(r.json)

    # Should have all the needed cjson components
    assert 'atoms' in cjson
    assert 'coords' in cjson['atoms']
    assert '3d' in cjson['atoms']['coords']
    assert len(cjson['atoms']['coords']['3d']) == 24  # 3 * 8 atoms = 24

    assert 'elements' in cjson['atoms']
    assert 'number' in cjson['atoms']['elements']
    assert cjson['atoms']['elements']['number'].count(1) == 6
    assert cjson['atoms']['elements']['number'].count(6) == 2
    assert len(cjson['atoms']['elements']['number']) == 8

    assert 'bonds' in cjson
    assert 'connections' in cjson['bonds']
    assert 'order' in cjson['bonds']
    assert len(cjson['bonds']['order']) == 7

def testTokenSessionDeletion(server, token):
    # With the token should succeed
    resp = server.request(path='/token/session', method='DELETE', token=token)
    assertStatusOk(resp)
    # Now the token is gone, so it should fail
    resp = server.request(path='/token/session', method='DELETE', token=token)
    assertStatus(resp, 401)

def test_put_properties(server, molecule, calculation, user):
    from girder.plugins.molecules.models.calculation import Calculation
    from girder.constants import AccessType

    assert '_id' in calculation
    assert 'moleculeId' in calculation
    assert 'properties' in calculation
    calc_id = str(calculation['_id'])
    calc_molecule_id = str(calculation['moleculeId'])
    calc_properties = calculation['properties']

    # We put these properties in ourselves
    assert 'molecular mass' in calc_properties
    assert 'boiling point' in calc_properties
    assert 'melting point' in calc_properties

    # Make sure these have the right values
    assert pytest.approx(calc_properties['molecular mass'], 1.e-4) == 30.0690
    assert calc_properties['melting point'] == -172
    assert calc_properties['boiling point'] == -88

    # Replace these properties with some new properties
    new_properties = {
        'critical temperature': 32.2,
        'critical pressure': 49.0
    }
    r = server.request('/calculations/%s/properties' % calc_id, method='PUT',
                       body=json.dumps(new_properties), user=user,
                       type='application/json')
    assertStatusOk(r)

    # Grab the new calculation
    updated_calc = Calculation().load(calc_id, level=AccessType.READ, user=user)

    # It should have an _id and a molecule id, and it should match
    assert '_id' in updated_calc
    assert 'moleculeId' in updated_calc
    assert 'properties' in updated_calc

    assert str(updated_calc['_id']) == calc_id
    assert str(updated_calc['moleculeId']) == calc_molecule_id

    # Make sure the old properties are no longer here
    updated_calc_properties = updated_calc['properties']
    assert 'molecular mass' not in updated_calc_properties
    assert 'boiling point' not in updated_calc_properties
    assert 'melting point' not in updated_calc_properties

    # The new properties should be here, though
    assert 'critical temperature' in updated_calc_properties
    assert 'critical pressure' in updated_calc_properties

    # Make sure these are correct also
    assert pytest.approx(
        updated_calc_properties['critical temperature'],
        1.e-1) == new_properties['critical temperature']
    assert pytest.approx(
        updated_calc_properties['critical pressure'],
        1.e-1) == new_properties['critical pressure']

def testPluginRestRoutes(server):
    resp = server.request('/describe')
    assertStatusOk(resp)
    assert '/other' in resp.json['paths']

    resp = server.request('/other')
    assertStatusOk(resp)
    assert resp.json == ['custom REST route']

def testLoadModelDecorator(server, user):
    resp = server.request(
        path='/accesstest/test_loadmodel_plain/%s' % user['_id'], method='GET')
    assertStatusOk(resp)
    assert resp.json['_id'] == str(user['_id'])

    resp = server.request(path='/accesstest/test_loadmodel_query', params={'userId': None})
    assertStatus(resp, 400)
    assert resp.json['message'] == 'Invalid ObjectId: None'

def apiKey(server, user):
    # Create a new API key with full access
    resp = server.request('/api_key', method='POST', params={
        'name': 'test key'
    }, user=user)
    assertStatusOk(resp)
    apiKey = ApiKey().load(resp.json['_id'], force=True)

    yield apiKey

def testMoveSubfolderToUser(server, admin, hierarchy):
    resp = server.request(
        path='/folder/%s' % hierarchy.folders[1]['_id'], method='PUT',
        user=admin, params={
            'parentId': admin['_id'],
            'parentType': 'user'
        })
    assertStatusOk(resp)
    assertNodeSize(admin, User, 10)
    assertNodeSize(hierarchy.collections[0], Collection, 1)

def testApiDocsContent(server):
    """
    Test content of API documentation page.
    """
    resp = server.request(path='/api/v1', method='GET', isJson=False, prefix='')
    assertStatusOk(resp)
    body = getResponseBody(resp)

    assert 'Girder REST API Documentation' in body
    assert 'This is not a sandbox' in body
    assert 'id="swagger-ui-container"' in body

def testTokenCreationDuration(server, user, apiKey):
    defaultDuration = Setting().get(SettingKey.COOKIE_LIFETIME)
    # We should be able to request a duration shorter than default
    resp = server.request('/api_key/token', method='POST', params={
        'key': apiKey['key'],
        'duration': defaultDuration - 1
    })
    assertStatusOk(resp)
    token = Token().load(
        resp.json['authToken']['token'], force=True, objectId=False)
    duration = token['expires'] - token['created']
    assert duration == datetime.timedelta(days=defaultDuration - 1)

def testUploaderUser(provisionedServer, smtp):
    # Create an uploader admin
    resp = provisionedServer.request(path='/user', method='POST', params={
        'email': '[email protected]',
        'login': 'uploader-admin',
        'firstName': 'uploader',
        'lastName': 'admin',
        'password': 'password'
    })
    assertStatusOk(resp)
    uploaderAdmin = User().findOne({'login': 'uploader-admin'})
    assert uploaderAdmin is not None
    contributorsGroup = Group().findOne({'name': 'Dataset Contributors'})
    assert contributorsGroup is not None
    Group().addUser(contributorsGroup, uploaderAdmin, level=AccessType.WRITE)

    # Create an uploader user
    resp = provisionedServer.request(path='/user', method='POST', params={
        'email': '[email protected]',
        'login': 'uploader-user',
        'firstName': 'uploader',
        'lastName': 'user',
        'password': 'password'
    })
    assertStatusOk(resp)
    uploaderUser = User().findOne({'login': 'uploader-user'})
    assert uploaderUser is not None

    # TODO: check if a user can upload without agreeing to terms

    # Ensure request create dataset permission works
    resp = provisionedServer.request(path='/user/requestCreateDatasetPermission',
                                     method='POST', user=uploaderUser)
    assertStatusOk(resp)
    assert smtp.waitForMail()
    assert smtp.getMail()  # pop off the queue for later assertion that the queue is empty

    # Ensure that the user can't create datasets yet
    resp = provisionedServer.request(path='/user/me', method='GET', user=uploaderUser)
    assertStatusOk(resp)
    assert not resp.json['permissions']['createDataset']

    # Ensure that a join request is pending
    contributorsGroup = Group().findOne({'name': 'Dataset Contributors'})
    joinRequestUserIds = [user['id'] for user in Group().getFullRequestList(contributorsGroup)]
    assert uploaderUser['_id'] in joinRequestUserIds
    assert smtp.isMailQueueEmpty()

    # Add the user, then ensure they can create datasets
    Group().inviteUser(contributorsGroup, uploaderUser, level=AccessType.READ)
    resp = provisionedServer.request(path='/user/me', method='GET', user=uploaderUser)
    assertStatusOk(resp)
    assert resp.json['permissions']['createDataset']

def testMoveFolderToNewCollection(server, admin, hierarchy):
    assertNodeSize(hierarchy.collections[0], Collection, 11)
    assertNodeSize(hierarchy.collections[1], Collection, 0)

    resp = server.request(
        path='/folder/%s' % hierarchy.folders[0]['_id'], method='PUT',
        user=admin, params={
            'parentId': hierarchy.collections[1]['_id'],
            'parentType': 'collection'
        })
    assertStatusOk(resp)
    assertNodeSize(hierarchy.collections[0], Collection, 0)
    assertNodeSize(hierarchy.collections[1], Collection, 11)

def testListScopes(server):
    resp = server.request('/token/scopes')
    assertStatusOk(resp)
    assert resp.json == TokenScope.listScopes()

    assert 'custom' in resp.json
    assert isinstance(resp.json['custom'], list)
    assert 'adminCustom' in resp.json
    assert isinstance(resp.json['adminCustom'], list)

    for scope in resp.json['custom'] + resp.json['adminCustom']:
        assert 'id' in scope
        assert 'name' in scope
        assert 'description' in scope

def testApiDocsCustomContent(server):
    """
    Test content of API documentation page that's customized by a plugin.
    """
    resp = server.request(path='/api/v1', method='GET', isJson=False, prefix='')
    assertStatusOk(resp)
    body = getResponseBody(resp)

    assert 'Girder REST API Documentation' not in body
    assert 'This is not a sandbox' not in body

    assert 'Girder Web Application Programming Interface' in body
    assert '<p>Custom API description</p>' in body
    assert 'id="swagger-ui-container"' in body

def testTokenCreatesUniqueTokens(server, user, apiKey):
    for _ in range(0, 2):
        resp = server.request('/api_key/token', method='POST', params={
            'key': apiKey['key']
        })
        assertStatusOk(resp)

    # We should have two tokens for this key
    q = {
        'userId': user['_id'],
        'apiKeyId': apiKey['_id']
    }
    count = Token().find(q).count()
    assert count == 2

def testInactiveKeyStructure(server, user, apiKey):
    newScopes = [TokenScope.DATA_READ, TokenScope.DATA_WRITE]
    resp = server.request('/api_key/%s' % apiKey['_id'], params={
        'active': False,
        'tokenDuration': 10,
        'scope': json.dumps(newScopes)
    }, method='PUT', user=user)
    assertStatusOk(resp)

    # Make sure key itself didn't change
    assert resp.json['key'] == apiKey['key']
    apiKey = ApiKey().load(resp.json['_id'], force=True)
    assert not apiKey['active']
    assert apiKey['tokenDuration'] == 10
    assert set(apiKey['scope']) == set(newScopes)

def testInactiveKeysCannotCreateTokens(server, user, apiKey):
    newScopes = [TokenScope.DATA_READ, TokenScope.DATA_WRITE]
    resp = server.request('/api_key/%s' % apiKey['_id'], params={
        'active': False,
        'tokenDuration': 10,
        'scope': json.dumps(newScopes)
    }, method='PUT', user=user)
    assertStatusOk(resp)

    # We should not be able to create tokens for this key anymore
    resp = server.request('/api_key/token', method='POST', params={
        'key': apiKey['key']
    })
    assertStatus(resp, 400)
    assert resp.json['message'] == 'Invalid API key.'