def test_config_bad_urls(self, mock_input, mock_load_config,
mock_save_config):
test_urls = [
'foo.com',
'ftp://foo.com',
'blah://bar.com',
'http://foo.bar.com/baz',
]
# test general URL setting -- result should match initial state
mock_load_config.return_value = {}
initial_url = command.get_registry_url()
for test_url in test_urls:
mock_input.return_value = test_url
with assertRaisesRegex(self, command.CommandException,
'Invalid URL'):
command.config()
assert mock_input.called
mock_input.reset_mock()
mock_save_config.assert_not_called()
assert command.get_registry_url() == initial_url
def test_login_token(self, mock_save):
old_refresh_token = "123"
refresh_token = "456"
access_token = "abc"
expires_at = 1000.0
self.requests_mock.add(responses.POST,
'%s/api/token' % command.get_registry_url(None),
json=dict(status=200,
refresh_token=refresh_token,
access_token=access_token,
expires_at=expires_at))
command.login_with_token(None, old_refresh_token)
assert self.requests_mock.calls[
0].request.body == "refresh_token=%s" % old_refresh_token
mock_save.assert_called_with({
command.get_registry_url(None):
dict(team=None,
refresh_token=refresh_token,
access_token=access_token,
expires_at=expires_at)
})
def _mock_logs_list(self, owner, package, pkg_hash):
logs_url = "%s/api/log/%s/%s/" % (command.get_registry_url(), owner,
package)
resp = dict(
logs=[dict(hash=pkg_hash, created=time.time(), author=owner)])
print("MOCKING URL=%s" % logs_url)
self.requests_mock.add(responses.GET, logs_url, json.dumps(resp))
def _mock_put_package(self, package, pkg_hash, upload_urls):
pkg_url = '%s/api/package/%s/%s' % (command.get_registry_url(),
package, pkg_hash)
# Dry run, then the real thing.
self.requests_mock.add(responses.PUT, pkg_url,
json.dumps(dict(upload_urls=upload_urls)))
self.requests_mock.add(responses.PUT, pkg_url, json.dumps(dict()))
def test_ambiguous_hash(self):
registry_url = command.get_registry_url(None)
session = command._get_session(None)
ambiguous_token = "795a7b"
# There should be at least two results that start with the ambiguous_token, plus some non-ambiguous
# results in fake_data to test against.
fake_data = {
'logs': [
{
'author':
'user',
'created':
1490816524.0,
'hash':
'885696c6e40613b3c601e95037caf4e43bda58c39f67ab5d5e56beefb3662ff4'
},
{
'author':
'user',
'created':
1490816507.0,
'hash':
'795a7bc9e40613b3c601e95037caf4e43bda58c39f67ab5d5e56beefb3662ff4'
},
{
'author':
'user',
'created':
1490816473.0,
'hash':
'795a7bc6e40613b3c601e95037caf4e43bda58c39f67ab5d5e56beefb3662ff4'
},
{
'author':
'user',
'created':
1490816524.0,
'hash':
'2501a6c6e40a7b355901fc5037caf4e43bda58c39f67ab5d5e56beefb3662ff4'
},
]
}
self.requests_mock.add(responses.GET,
registry_url + "/api/log/user/test/",
json=fake_data)
# Ambiguous hashes in _match_hash's exception will be sorted -- sorted here to match.
fake_data_ambiguous = sorted(
entry['hash'] for entry in fake_data['logs']
if entry['hash'].startswith(ambiguous_token))
# this will match each ambiguous hash, in order, separated by anything.
# ..it allows for formatting changes in the error, but requires the same order.
fake_data_regexp = r'(.|\n)+'.join(fake_data_ambiguous)
with assertRaisesRegex(self, command.CommandException,
fake_data_regexp):
command._match_hash(session,
team=None,
owner='user',
pkg='test',
hash='795a7b')
def test_login_token_server_error(self, mock_save):
self.requests_mock.add(responses.POST,
'%s/api/token' % command.get_registry_url(),
status=500)
with self.assertRaises(command.CommandException):
command.login_with_token("123")
mock_save.assert_not_called()
def test_login_token_auth_fail(self, mock_save):
self.requests_mock.add(responses.POST,
'%s/api/token' % command.get_registry_url(),
json=dict(status=200, error="Bad token!"))
with self.assertRaises(command.CommandException):
command.login_with_token("123")
mock_save.assert_not_called()
def test_login(self, mock_login_with_token, mock_input, mock_open):
old_refresh_token = "123"
mock_input.return_value = old_refresh_token
command.login()
mock_open.assert_called_with('%s/login' % command.get_registry_url())
mock_login_with_token.assert_called_with(old_refresh_token)
def test_delete_confirmed(self, mock_input):
owner = 'foo'
package = 'bar'
mock_input.return_value = '%s/%s' % (owner, package)
delete_url = "%s/api/package/%s/%s/" % (command.get_registry_url(),
owner, package)
self.requests_mock.add(responses.DELETE, delete_url,
json.dumps(dict()))
command.delete('%s/%s' % (owner, package))
def test_config_urls_default(self, mock_input, mock_load_config,
mock_save_config):
# test setting default URL with blank string -- result should be default
mock_load_config.return_value = {}
mock_input.return_value = ''
command.config()
assert mock_input.called
args, kwargs = mock_save_config.call_args
mock_load_config.return_value = args[0] if args else kwargs['cfg']
assert command.get_registry_url() == command.DEFAULT_REGISTRY_URL
def test_login_not_allowed(self, mock_open, mock_load, mock_save):
# Already logged is as a public user.
mock_load.return_value = {
command.get_registry_url(None): dict(team=None)
}
# Normal login is ok.
command.login(None)
mock_open.reset_mock()
mock_save.reset_mock()
# Team login is not allowed.
with self.assertRaises(command.CommandException):
command.login('foo')
mock_open.assert_not_called()
mock_save.assert_not_called()
# Already logged is as a team user.
mock_load.return_value = {
command.get_registry_url('foo'): dict(team='foo')
}
# Normal login is not allowed.
with self.assertRaises(command.CommandException):
command.login(None)
# Login as 'foo' is ok.
command.login('foo')
mock_open.reset_mock()
mock_save.reset_mock()
# Login as a different team is not allowed.
with self.assertRaises(command.CommandException):
command.login('bar')
mock_open.assert_not_called()
mock_save.assert_not_called()
def test_version_add_confirmed(self, mock_input, mock_match_hash):
registry_url = command.get_registry_url()
mock_input.return_value = 'y'
mock_match_hash.return_value = 'fabc123'
# Response content is not checked by version_add, so
# status ok and URL verification are enough
self.requests_mock.add(
responses.PUT,
registry_url + "/api/version/user/test/2.9.12",
status=200,
)
command.version_add('user/test', '2.9.12', 'fabc123')
def test_logging(self):
mydir = os.path.dirname(__file__)
build_path = os.path.join(mydir, './build_simple.yml')
log_url = '%s/api/log' % (command.get_registry_url(), )
# Successful logging response.
with patch('quilt.tools.command._load_config', return_value={}):
def callback(request):
data = json.loads(request.body)
assert data == [
dict(
type='build',
package=hashlib.md5(b'foo/bar').hexdigest(),
dry_run=False,
env='default',
)
]
return (200, {}, '')
self.requests_mock.add_callback(responses.POST, log_url, callback)
command.build('foo/bar', build_path)
# Failed logging response.
with patch('quilt.tools.command._load_config', return_value={}):
self.requests_mock.add(responses.POST, log_url, status=500)
command.build('foo/bar', build_path)
# ConnectionError
with patch('quilt.tools.command._load_config', return_value={}):
self.requests_mock.add(responses.POST,
log_url,
body=requests.exceptions.ConnectionError())
command.build('foo/bar', build_path)
# Disabled logging.
with patch('quilt.tools.command._load_config',
return_value={'disable_analytics': True}):
self.requests_mock.add(responses.POST,
log_url,
body=AssertionError('Unexpected logging!'))
command.build('foo/bar', build_path)
self.requests_mock.reset(
) # Prevent the "not all requests ..." assert.
def test_config_good_urls(self, mock_input, mock_load_config,
mock_save_config):
test_urls = [
'https://foo.com',
'http://foo.com',
'https://foo.bar.net',
]
# test general URL setting -- result should match input
for test_url in test_urls:
mock_load_config.return_value = {}
mock_input.return_value = test_url
command.config()
assert mock_input.called
mock_input.reset_mock()
args, kwargs = mock_save_config.call_args
mock_load_config.return_value = args[0] if args else kwargs['cfg']
assert test_url == command.get_registry_url()
def _mock_update_package(self, package, subpath, contents, upload_urls):
pkg_url = '%s/api/package_update/%s/%s' % (
command.get_registry_url(None), package, subpath)
# Dry run, then the real thing.
def callback1(request):
data = _decode_body(request.body)
assert data['dry_run']
assert data['contents'] == contents
return (200, {}, json.dumps(dict(upload_urls=upload_urls)))
def callback2(request):
data = _decode_body(request.body)
assert not data['dry_run']
assert data['contents'] == contents
return (200, {},
json.dumps(dict(package_url='https://example.com/')))
self.requests_mock.add_callback(responses.POST, pkg_url, callback1)
self.requests_mock.add_callback(responses.POST, pkg_url, callback2)
def _mock_put_tag(self, package, tag):
tag_url = '%s/api/tag/%s/%s' % (command.get_registry_url(), package,
tag)
self.requests_mock.add(responses.PUT, tag_url, json.dumps(dict()))
