def crash_ids_generator(num_results):
params = {
'_columns': 'uuid',
'_results_offset': 0,
'_results_number': min(MAX_PAGE, num_results),
}
crashids_count = 0
while True:
resp = molotov.json_request(SUPERSEARCH_API,
verb='GET',
params=params)
hits = resp['content']['hits']
for hit in hits:
crashids_count += 1
yield hit['uuid']
if crashids_count >= num_results:
return
total = resp['content']['total']
if not hits or crashids_count >= total:
return
params['_results_offset'] += MAX_PAGE
params['_results_number'] = min(
# MAX_PAGE is the maximum we can request
MAX_PAGE,
# The number of results Super Search can return to us that is
# hasn't returned so far
total - crashids_count,
# The number of results we want that we haven't gotten, yet
num_results - crashids_count)
def _setup(args):
_HEADERS['Authorization'] = "Bearer %s" % _ACCESS_TOKEN
calendar = molotov.json_request("%s/me/calendar" % _GCAPI, headers=_HEADERS)['content']
molotov.set_var('calendar', calendar)
if _NOW:
now = dateutil.parser.parse(_NOW)
else:
now = datetime.now()
print("\nBase datetime: %s (%s)\n" % (now, _LOCAL_TZ))
molotov.set_var('now', now)
def get_test_experiments():
""" Return test experiments """
url = urljoin(get_api_url(), 'experiments/running')
exp_running = molotov.json_request(url)['content']
exp_test = [(exp["id"], exp["user"]) for exp in exp_running["items"]
if 'monkey' in exp['name']]
# thread-safe structure for molotov workers/processes
experiments = Queue()
if exp_test:
for exp in exp_test:
experiments.put(exp)
return experiments
def get_test_users(config):
""" Return test users """
# thread-safe structure for molotov workers/processes
users = Queue()
groups = molotov.json_request(urljoin(get_api_url(), 'groups'),
auth=get_auth())['content']
group = [group for group in groups if group['name'] == config['group']]
# check if group exists
if group:
for user in group[0]['users']:
users.put(user)
return users
def generate(self):
"""Pick an identity, log in and generate the auth token."""
# If the server_url has a hash fragment, it's a storage node and
# that's the secret. Otherwise it's a token server url.
uid = random.randint(1, 1000000)
url = urlparse(self.server_url)
if url.fragment:
endpoint = url._replace(fragment="", path="/1.5/" + str(uid))
self.endpoint_url = urlunparse(endpoint)
data = {
"uid": uid,
"node": urlunparse(url._replace(fragment="")),
"expires": time.time() + ASSERTION_LIFETIME,
}
self.auth_token = make_token(data, secret=url.fragment)
self.auth_secret = derive(self.auth_token, secret=url.fragment)
else:
email = "user%s@%s" % (uid, MOCKMYID_DOMAIN)
exp = time.time() + ASSERTION_LIFETIME + self.timeskew
assertion = browserid.tests.support.make_assertion(
email=email,
audience=self.server_url,
issuer=MOCKMYID_DOMAIN,
issuer_keypair=(None, MOCKMYID_PRIVATE_KEY),
exp=int(exp * 1000),
)
token_url = self.server_url + "/1.0/sync/1.5"
response = json_request(token_url,
headers={
"Authorization":
"BrowserID " + assertion,
})
# Maybe timeskew between client and server?
if response['status'] == 401:
server_time = int(response['headers']["X-Timestamp"])
self.timeskew = server_time - int(time.time())
exp = time.time() + ASSERTION_LIFETIME + self.timeskew
assertion = browserid.tests.support.make_assertion(
email=email,
audience=self.server_url,
issuer=MOCKMYID_DOMAIN,
issuer_keypair=(None, MOCKMYID_PRIVATE_KEY),
exp=int(exp * 1000),
)
response = json_request(token_url,
headers={
"Authorization":
"BrowserID " + assertion,
})
if response['status'] > 299:
raise ValueError(response['status'])
credentials = response['content']
self.auth_token = credentials["id"].encode('ascii')
self.auth_secret = credentials["key"].encode('ascii')
self.endpoint_url = credentials["api_endpoint"]
url = urlparse(self.endpoint_url)
self.endpoint_scheme = url.scheme
self.endpoint_path = url.path
if ':' in url.netloc:
self.endpoint_host, self.endpoint_port = url.netloc.rsplit(":", 1)
else:
self.endpoint_host = url.netloc
if url.scheme == "http":
self.endpoint_port = "80"
else:
self.endpoint_port = "443"
def get_test_site(config):
""" Return test site """
url = urljoin(get_api_url(), 'sites')
sites_dict = molotov.json_request(url)['content']
sites = [site["site"] for site in sites_dict["items"]]
return [site for site in sites if config['site'] in site][0]
def init_test(args):
_HEADERS['Authorization'] = "Bearer %s" % _ACCESS_TOKEN
me = molotov.json_request("%s/me" % _GCAPI, headers=_HEADERS)['content']
molotov.set_var('me', me)
def regenerate(self):
"""Generate an auth token for the selected identity."""
# If the server_url has a hash fragment, it's a storage node and
# that's the secret. Otherwise it's a token server url.
uid = self.uid
url = urlparse(self.server_url)
if url.fragment:
endpoint = url._replace(
path=url.path.rstrip("/") + "/1.5/" + str(uid),
fragment="",
)
self.endpoint_url = urlunparse(endpoint)
token_duration = ASSERTION_LIFETIME
# Some storage backends use the numeric tokenserver uid, and some use
# the raw fxa uid and kid. Let's include mock values for both cases,
# with everything derived from the mock uid for consistency..
data = {
"uid":
uid,
"fxa_uid":
hashlib.sha256(
"{}:fxa_uid".format(uid).encode("ascii")).hexdigest(),
"fxa_kid":
hashlib.sha256(
"{}:fxa_kid".format(uid).encode("ascii")).hexdigest()[:32],
"hashed_fxa_uid":
hashlib.sha256("{}:hashed_fxa_uid".format(uid).encode(
"ascii")).hexdigest(),
"node":
urlunparse(url._replace(path="", fragment="")),
"expires":
time.time() + token_duration,
}
auth_token = make_token(data, secret=url.fragment)
self.auth_token = auth_token.encode("ascii")
self.auth_secret = derive(auth_token,
secret=url.fragment).encode("ascii")
self.auth_expires_at = data["expires"]
else:
email = "user%s@%s" % (uid, MOCKMYID_DOMAIN)
exp = time.time() + ASSERTION_LIFETIME + self.timeskew
assertion = browserid.tests.support.make_assertion(
email=email,
audience=urlunparse(url._replace(path="")),
issuer=MOCKMYID_DOMAIN,
issuer_keypair=(None, MOCKMYID_PRIVATE_KEY),
exp=int(exp * 1000),
)
token_url = self.server_url + "/1.0/sync/1.5"
response = json_request(token_url,
headers={
"Authorization":
"BrowserID " + assertion,
})
# Maybe timeskew between client and server?
if response['status'] == 401:
server_time = int(response['headers']["X-Timestamp"])
self.timeskew = server_time - int(time.time())
exp = time.time() + ASSERTION_LIFETIME + self.timeskew
assertion = browserid.tests.support.make_assertion(
email=email,
audience=self.server_url,
issuer=MOCKMYID_DOMAIN,
issuer_keypair=(None, MOCKMYID_PRIVATE_KEY),
exp=int(exp * 1000),
)
response = json_request(token_url,
headers={
"Authorization":
"BrowserID " + assertion,
})
if response['status'] > 299:
raise ValueError(response['status'])
credentials = response['content']
self.auth_token = credentials["id"].encode('ascii')
self.auth_secret = credentials["key"].encode('ascii')
self.endpoint_url = credentials["api_endpoint"]
token_duration = credentials['duration']
# Regenerate tokens when they're close to expiring
# but before they actually expire, to avoid spurious 401s.
self.auth_expires_at = time.time() + (token_duration * 0.5)
url = urlparse(self.endpoint_url)
self.endpoint_scheme = url.scheme
self.endpoint_path = url.path
self.host_header = url.netloc
if ':' in url.netloc:
self.endpoint_host, self.endpoint_port = url.netloc.rsplit(":", 1)
else:
self.endpoint_host = url.netloc
if url.scheme == "http":
self.endpoint_port = "80"
else:
self.endpoint_port = "443"
