Ejemplo n.º 1
0
async def test_single_resolver(query):
    with mock.patch('mongodb_streams.find_one', ) as m:
        m.side_effect = [dict(username='******'), dict(name='name')]
        r = await query('''
        {
            bot(where: {username: {eq: "ciao"}}) {
                username
                user {
                    name
                }
            }
        }
        ''')
        pretty(r)
        pretty(m.call_args_list)
        assert r == {
            "data": {
                "bot": {
                    "username": "******",
                    "user": {
                        "name": "name"
                    }
                }
            }
        }
Ejemplo n.º 2
0
async def test_many_relation(query):
    with mock.patch('mongodb_streams.find_one', ) as m:
        m.side_effect = [[
            dict(username='******'),
        ], [dict(value=89, timestamp=34)]]
        r = await query('''
            {
                bots(
                    last: 50,
                ) {
                    nodes {
                        username
                        _id
                        likes_over_time(
                            first: 20
                            cursorField: value
                        ) {
                            nodes {
                                value
                                timestamp
                            }
                        }
                    }
                }
            }
        ''')
        pretty(r)
        pretty(m.call_args_list)
Ejemplo n.º 3
0
def test_first_and_after_desc(query, users: Collection):
    assert not list(users.find({}))
    LENGTH = 20
    users.insert_many(
        [dict(_id=ObjectId(), name=str(i)) for i in range(LENGTH)])
    q = r"""
        query search($first: Int!, $after: AnyScalar) {
            UserNodes(first: $first, after: $after, cursorField: _id, direction: DESC) {
                nodes {
                    _id
                    name
                    url
                }
                pageInfo {
                    hasPreviousPage
                    hasNextPage
                    startCursor
                    endCursor
                }
            }
        }
      """
    res = query(q, dict(first=10))
    pretty(res)
    assert res["data"]["UserNodes"]["nodes"]
    assert len(res["data"]["UserNodes"]["nodes"]) == 10
    after = res["data"]["UserNodes"]["pageInfo"]["endCursor"]
    res = query(q, dict(first=10, after=after))
    pretty(res)
    assert res["data"]["UserNodes"]["nodes"]
    assert len(res["data"]["UserNodes"]["nodes"]) == 10
Ejemplo n.º 4
0
def test_before_and_last_different_cursor(query, users: Collection):
    assert not list(users.find({}))
    users.insert_many([dict(_id=ObjectId(), name=str(i)) for i in LETTERS])
    q = r"""
        query search($last: Int!, $before: AnyScalar) {
            UserNodes(last: $last, before: $before, cursorField: name, direction: ASC) {
                nodes {
                    _id
                    name
                    url
                }
                pageInfo {
                    hasPreviousPage
                    hasNextPage
                    startCursor
                    endCursor
                }
            }
        }
      """
    res = query(q, dict(last=10))
    pretty(res)
    assert res["data"]["UserNodes"]["nodes"]
    assert len(res["data"]["UserNodes"]["nodes"]) == 10
    before = res["data"]["UserNodes"]["pageInfo"]["startCursor"]
    res = query(q, dict(last=10, before=before))
    pretty(res)
    assert res["data"]["UserNodes"]["nodes"]
    assert len(res["data"]["UserNodes"]["nodes"]) == 10
Ejemplo n.º 5
0
def test_get_user(query):
    q = """
        {
            User {
                _id
                name
            }
        }

      """
    res = query(q)
    pretty(res)
Ejemplo n.º 6
0
def test_no_error(query, users: Collection):
    assert not list(users.find({}))
    q = """
        {
            User {
                _id
                name
            }
        }

      """
    res = query(q)
    pretty(res)
    assert not res.get("errors")
Ejemplo n.º 7
0
async def test_many_resolver(query):
    with mock.patch('mongodb_streams.find', ) as m:
        bots = [dict(_id=str(i), username=str(i)) for i in range(20)]
        m.return_value = bots
        r = await query('''
        {
            bots(first: 3) {
                nodes {
                    username
                }
            }
        }
        ''')
        pretty(r, )
        print(m.call_args)
Ejemplo n.º 8
0
def test_objectid_error(query, users: Collection):
    assert not list(users.find({}))
    q = """
        {
            User(where: {_id: {eq: "kjh"}}) {
                _id
                name
            }
        }

      """
    res = query(q)
    pretty(res)
    assert res["errors"]
    pretty(res["errors"][0]["message"])
Ejemplo n.º 9
0
def test_single_resolver(query):
    with mock.patch("mongodb_streams.find_one") as m:
        m.side_effect = [dict(surname="xxx")]
        r = query("""
            {
                User(where: {surname: {eq: "xxx"}}) {
                    _id
                    name
                    surname
                }
            }
        """)
        pretty(r)
        pretty(m.call_args_list)
        assert r["data"]["User"]["surname"] == "xxx"
Ejemplo n.º 10
0
def test_get_user_real(query, users: Collection):
    assert not list(users.find({}))
    users.insert_one(dict(name="xxx"))
    q = """
        {
            User {
                _id
                name
                url
            }
        }

      """
    res = query(q)
    pretty(res)
    assert res["data"]["User"]
Ejemplo n.º 11
0
def now_handler(event, ctx):
    handler = Mangum(app, )
    pretty(json.loads(event['body']))
    try:
        res = handler(map_event(event), ctx)
        pretty(res)
        return map_response(res)
    except Exception as e:
        traceback.print_exc()
        return {
            "statusCode": 500,
            "headers": {
                "content-type": "text/plain; charset=utf-8"
            },
            "body": str(e),
        }
Ejemplo n.º 12
0
def test_cursor_field(query):
    with mock.patch("mongodb_streams.find") as m:
        xs = [dict(surname=i) for i in iter(LETTERS)]
        m.return_value = xs
        r = query("""
            {
                UserNodes(cursorField: surname) {
                    nodes {
                        surname
                    }
                }
            }
            """)
        pretty(r)
        print(m.call_args)
        nodes = r["data"]["UserNodes"]["nodes"]
        assert len(nodes) == len(LETTERS)
        assert sorted(nodes, key=lambda x: x["surname"]) == nodes
Ejemplo n.º 13
0
def test_many_users(query):
    with mock.patch("mongodb_streams.find") as m:
        m.side_effect = [[dict(surname="xxx")], [dict(surname="xxx")]]
        r = query("""
                {
                    UserNodes(where: { surname: { eq: "xxx" } }) {
                        nodes {
                            surname
                        }
                    }
                }

            """)
        pretty(r)
        pretty(m.call_args_list)
        nodes = r["data"]["UserNodes"]["nodes"]
        assert len(nodes) == 1
        assert nodes[0]["surname"] == "xxx"
Ejemplo n.º 14
0
def test_id_is_searchable(query, users: Collection):
    assert not list(users.find({}))
    id = ObjectId()
    users.insert_one(dict(_id=id, name="xxx"))
    q = """
        query search($id: ObjectId!) {
            User(where: {_id: {eq: $id}}) {
                _id
                name
                url
            }
        }

      """
    res = query(q, dict(id=str(id)))
    pretty(res)
    assert res["data"]["User"]
    assert res["data"]["User"]["_id"] == str(id)
Ejemplo n.º 15
0
def test_many_resolver(query):
    with mock.patch("mongodb_streams.find") as m:
        bots = [dict(_id=str(i), username=str(i)) for i in range(20)]
        m.return_value = bots
        r = query("""
            {
                UserNodes(where: { surname: { eq: "xxx" } }) {
                    nodes {
                        surname
                        friends {
                            nodes {
                                surname
                            }
                        }
                    }
                }
            }
            """)
        pretty(r)
        print(m.call_args)
Ejemplo n.º 16
0
async def connection_resolver(
    collection: AsyncIOMotorCollection,
    where: dict,
    cursorField,  # needs to exist always at least one, the fisrst is the cursorField
    pagination: dict,
    scalar_name,
    pipeline=[],
):
    if os.getenv('DEBUG'):
        print('executing connection_resolver')
        pretty({
            'where': where,
            'cursorField': cursorField,
            'pagination': pagination,
            'scalar_name': scalar_name,
            'collection': collection,
            'pipeline': pipeline,
        })
    direction = pagination['direction']
    first, last = pagination.get('first'), pagination.get('last'),
    after, before = pagination.get('after'), pagination.get('before')
    if after:
        after = INPUT_COERCERS.get(scalar_name, lambda x: x)(after)
    if before:
        before = INPUT_COERCERS.get(scalar_name, lambda x: x)(before)

    first = first or 0
    last = last or 0

    if not first and not last:
        if after:
            first = DEFAULT_NODES_COUNT
        elif before:
            last = DEFAULT_NODES_COUNT
        else:
            first = DEFAULT_NODES_COUNT

    if after and not (first or before):
        raise Exception('need `first` or `before` if using `after`')
    if before and not (last or after):
        raise Exception('need `last` or `after` if using `before`')
    if first and last:
        raise Exception('no sense using first and last together')

    args: dict = dict()
    lt = '$gt' if direction == DESCENDING else '$lt'
    gt = '$lt' if direction == DESCENDING else '$gt'
    if after != None and before != None:
        args.update(
            dict(match={
                **where,
                cursorField: {
                    gt: after,
                    lt: before
                },
            }, ))
    elif after != None:
        args.update(dict(match={
            **where,
            cursorField: {
                gt: after,
            },
        }, ))
    elif before != None:
        args.update(dict(match={
            **where,
            cursorField: {
                lt: before
            },
        }, ))
    else:
        args = dict(match=where, )
    if pipeline:
        args.update(dict(pipeline=pipeline))
    sorting = direction if not last else opposite_direction(direction)
    args.update(dict(sort={cursorField: sorting}))
    if last:
        args.update(dict(limit=last + 1, ))
    if first:
        args.update(dict(limit=first + 1, ))
    # elif first:
    #     count = await mongodb_streams.count_documents(collection, args['match'], pipeline=pipeline)
    #     toSkip = count - (last + 1)
    #     args.update(dict(skip=max(toSkip, 0)))
    args.update(dict(max_len=10000))
    # pretty(args)
    nodes = await mongodb_streams.find(collection, **args)

    hasNext = None
    hasPrevious = None

    if first:
        hasNext = len(nodes) == (first + 1)
        nodes = nodes[:-1] if hasNext else nodes

    if last:
        nodes = list(reversed(nodes))
        hasPrevious = len(nodes) == (last + 1)
        nodes = nodes[1:] if hasPrevious else nodes

    end_cursor = nodes[-1].get(cursorField) if nodes else None
    start_cursor = nodes[0].get(cursorField) if nodes else None
    return {
        'nodes':
        nodes,
        'edges':
        lmap(
            lambda node: dict(node=node,
                              cursor=OUTPUT_COERCERS[scalar_name]
                              (node.get(cursorField))), nodes),
        'pageInfo': {
            'endCursor':
            end_cursor and OUTPUT_COERCERS[scalar_name](end_cursor),
            'startCursor':
            start_cursor and OUTPUT_COERCERS[scalar_name](start_cursor),
            'hasNextPage':
            hasNext,
            'hasPreviousPage':
            hasPrevious,
        }
    }
Ejemplo n.º 17
0
def hello(request):
    pretty(dir(request))
    pretty(request.json)
    return "Hello world!"