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}/')
