def test_simple(self): class Foo: pass @snug.query.from_request_func(rtype=t.List[Post]) def posts(count: int, search: str='', archived: bool=False): """my docstring...""" return snug.Request( 'posts/', params={'max': count, 'search': search, 'archived': archived}) assert posts.__name__ == 'posts' assert posts.__doc__ == 'my docstring...' assert posts.__module__ == Foo.__module__ assert issubclass(posts, snug.Query) assert len(posts.__dataclass_fields__) == 3 my_posts = posts(count=10, search='important') assert isinstance(my_posts, snug.Query) assert my_posts.count == 10 assert my_posts.search == 'important' assert my_posts.__rtype__ == t.List[Post] assert my_posts.__req__ == snug.Request( 'posts/', params={'max': 10, 'search': 'important', 'archived': False})
def test_resolve(): loaders = {Post: lambda data: Post(**data)}.__getitem__ @snug.Query(Post) def post(id: int): """a post by its ID""" return snug.Request(f'posts/{id}/') query = post(id=4) api = snug.Api( prepare=methodcaller('add_prefix', 'mysite.com/api/'), parse=compose( json.loads, methodcaller('decode'), attrgetter('content')), add_auth=lambda req, auth: req.add_headers({'Authorization': 'me'}), ) sender = MockSender([ (snug.Request('mysite.com/api/posts/4/', headers={'Authorization': 'me'}), snug.Response(200, b'{"id": 4, "title": "my post!"}', headers={})) ]) response = snug.resolve(query, api=api, sender=sender, auth='me', loaders=loaders) assert isinstance(response, Post) assert response == Post(id=4, title='my post!')
def test_current_user_issues(): assert isinstance(my_issues, snug.Query) assert my_issues.__rtype__ == t.List[gh.Issue] assert my_issues.__req__ == snug.Request('user/issues') if live: issues = resolve(my_issues) assert isinstance(issues, list)
def test_http_error(): err = quiz.HTTPError( snug.Response(404, content=b"not found!\x00"), snug.Request("POST", "https://my.url/api"), ) assert "not found!\\x00" in str(err) assert "404" in str(err) assert "my.url" in str(err)
def issues(repo: 'repo', labels: t.Optional[str] = None, state: t.Optional[str] = None): return snug.Request(f'repos/{repo.owner}/{repo.name}/issues', params=valfilter(notnone, { 'labels': labels, 'state': state, }))
def test_current_user(): assert isinstance(current_user, snug.Query) assert current_user.__rtype__ == gh.User assert current_user.__req__ == snug.Request('user') if live: me = resolve(current_user) assert isinstance(me, gh.User)
def test_as_decorator_no_call(self): @snug.Query def post(id: int): return snug.Request(f'posts/{id}/') assert issubclass(post, snug.Query) assert post(5).__req__ == snug.Request('posts/5/') assert post.__rtype__ is object
def test_no_defaults(self): @snug.query.from_request_func(rtype=Post) def post(id: int): """a post by its ID""" return snug.Request(f'posts/{id}/') my_post = post(id=5) assert my_post.__req__ == snug.Request('posts/5/')
def test_as_decorator_with_type(self): @snug.Query(Post) def post(id: int): return snug.Request(f'posts/{id}/') assert issubclass(post, snug.Query) assert post(5).__req__ == snug.Request('posts/5/') assert post.__rtype__ is Post
def test_one_repo(): assert isinstance(one_repo, snug.Query) assert one_repo.__rtype__ == gh.Repo assert one_repo.__req__ == snug.Request('repos/github/hub') if live: repo = resolve(one_repo) assert isinstance(repo, gh.Repo) assert repo.name == 'hub'
def test_one_org(): assert isinstance(one_org, snug.Query) assert one_org.__rtype__ == gh.Organization assert one_org.__req__ == snug.Request('orgs/github') if live: org = resolve(one_org) assert isinstance(org, gh.Organization) assert org.login == 'github'
def test_all_orgs(): assert isinstance(all_orgs, snug.Query) assert all_orgs.__rtype__ == t.List[gh.Organization] assert all_orgs.__req__ == snug.Request('organizations') if live: orgs = resolve(all_orgs) assert isinstance(orgs, list) assert len(orgs) > 1
def test_assigned_issues(): assert isinstance(assigned_issues, snug.Query) assert assigned_issues.__rtype__ == t.List[gh.Issue] assert assigned_issues.__req__ == snug.Request('issues') if live: issues = resolve(assigned_issues) assert isinstance(issues, list) assert len(issues) > 1 assert isinstance(issues[0], gh.Issue)
def test_all_repos(): assert isinstance(all_repos, snug.Query) assert all_repos.__rtype__ == t.List[gh.RepoSummary] assert all_repos.__req__ == snug.Request('repositories') if live: repos = resolve(all_repos) assert isinstance(repos, list) assert len(repos) > 1 assert isinstance(repos[0], gh.RepoSummary)
def test_all_repo_issues(): assert isinstance(repo_issues, snug.Query) assert repo_issues.__rtype__ == t.List[gh.Issue] assert repo_issues.__req__ == snug.Request( 'repos/github/hub/issues') if live: issues = resolve(repo_issues) assert isinstance(issues, list) assert len(issues) > 1 assert isinstance(issues[0], gh.Issue)
def test_departures(): assert isinstance(departures, snug.Query) assert departures.__rtype__ == t.List[ns.Departure] assert departures.__req__ == snug.Request('avt', params={'station': 'amsterdam'}) if live: deps = resolve(departures) assert len(deps) >= 10 departure = deps[0] assert isinstance(departure, ns.Departure)
def test_filtered_repo_issues(): assert isinstance(one_repos_fixed_bugs, snug.Query) assert one_repos_fixed_bugs.__rtype__ == t.List[gh.Issue] assert one_repos_fixed_bugs.__req__ == snug.Request( 'repos/github/hub/issues', params=dict(labels='bug', state='closed')) if live: issues = resolve(one_repos_fixed_bugs) assert isinstance(issues, list) assert len(issues) > 1 assert isinstance(issues[0], gh.Issue)
def test_equality(self): req = snug.Request('GET', 'my/url') other = req.replace() assert req == other assert not req != other assert not req == req.replace(headers={'foo': 'bar'}) assert req != req.replace(headers={'foo': 'bar'}) assert req == AlwaysEquals() assert not req != AlwaysEquals() assert req != AlwaysInEquals() assert not req == AlwaysInEquals()
def middleware(url, query_str): # type: (str, str) -> snug.Query[Dict[str, JSON]] response = yield snug.Request( 'POST', url, content=json.dumps({'query': query_str}).encode('ascii'), headers={'Content-Type': 'application/json'} ) if response.status_code >= 400: raise HTTPError(response) content = json.loads(response.content.decode('utf-8')) if 'errors' in content: raise ErrorResponse(**content) return_(content['data'])
def test_subclassing(self): @dataclass(frozen=True) class posts(snug.Query, rtype=t.List[Post]): count: int @property def __req__(self): return Request('posts/', params={'max': self.count}) query = posts(count=2) assert isinstance(query, snug.Query) assert query.count == 2 assert query.__rtype__ is t.List[Post] assert query.__req__ == snug.Request('posts/', params={'max': 2})
def test_journey_options(): assert isinstance(travel_options, snug.Query) assert travel_options.__rtype__ == t.List[ns.Journey] assert travel_options.__req__ == snug.Request('treinplanner', params={ 'fromStation': 'breda', 'toStation': 'amsterdam' }) if live: options = resolve(travel_options) assert len(options) >= 10 assert isinstance(options[0], ns.Journey) assert isinstance(travel_options_no_hsl, snug.Query) assert travel_options_no_hsl.__req__ == snug.Request('treinplanner', params={ 'fromStation': 'breda', 'toStation': 'amsterdam', 'hslAllowed': 'false' })
def issues(filter: t.Optional[str] = None, state: t.Optional[Issue.State] = None, labels: t.Optional[str] = None, sort: t.Optional[Issue.Sort] = None, since: t.Optional[datetime] = None): """a selection of assigned issues""" return snug.Request('issues', params=valfilter( notnone, { 'filter': filter, 'state': state, 'labels': labels, 'sort': sort, 'since': since, }))
def test_all_stations(): assert isinstance(all_stations, snug.Query) assert all_stations.__rtype__ == t.List[ns.Station] assert all_stations.__req__ == snug.Request('stations-v2') if live: stations = resolve(all_stations) assert isinstance(stations, list) amsterdam_stations = [ s for s in stations if s.full_name.startswith('Amsterdam') ] assert len(amsterdam_stations) == 11 den_bosch = stations[0] assert den_bosch.synonyms == ["Hertogenbosch ('s)", 'Den Bosch']
def repo(name: str, owner: str): """a repository lookup by owner and name""" return snug.Request(f'api.github.com/repos/{owner}/{name}')
def test_init_defaults(self): recent_posts = snug.Query(snug.Request('posts/recent/')) assert recent_posts.__req__ == snug.Request('posts/recent/') assert recent_posts.__rtype__ is object
def test_init(self): recent_posts = snug.Query(request=snug.Request('posts/recent/'), rtype=t.List[Post]) assert isinstance(recent_posts, snug.Query) assert recent_posts.__req__ == snug.Request('posts/recent/') assert recent_posts.__rtype__ is t.List[Post]
def post(id: int): """a post by its ID""" return snug.Request(f'mysite.com/posts/{id}/')
def post(id: int): """a post by its ID""" return snug.Request(f'posts/{id}/')
def posts(count: int, search: str='', archived: bool=False): """my docstring...""" return snug.Request( 'posts/', params={'max': count, 'search': search, 'archived': archived})
def post(id: int): return snug.Request(f'posts/{id}/')