def _post(self, transaction, changed_by):
if connexion.request.get_json().get("when", None) is None:
return problem(400, "Bad Request", "'when' cannot be set to null when scheduling a new change "
"for a Release")
change_type = connexion.request.get_json().get("change_type")
what = {}
for field in connexion.request.get_json():
if field == "csrf_token":
continue
what[field] = connexion.request.get_json()[field]
if change_type == "update":
if not what.get("data_version", None):
return problem(400, "Bad Request", "Missing field", ext={"exception": "data_version is missing"})
if what.get("data", None):
what["data"] = createBlob(what.get("data"))
elif change_type == "insert":
if not what.get("product", None):
return problem(400, "Bad Request", "Missing field", ext={"exception": "product is missing"})
if what.get("data", None):
what["data"] = createBlob(what.get("data"))
else:
return problem(400, "Bad Request", "Missing field", ext={"exception": "Missing blob 'data' value"})
elif change_type == "delete":
if not what.get("data_version", None):
return problem(400, "Bad Request", "Missing field", ext={"exception": "data_version is missing"})
return super(ReleaseScheduledChangesView, self)._post(what, transaction, changed_by, change_type)
def testSchemaCaching(self):
with mock.patch("yaml.load") as yaml_load:
yaml_load.return_value = {
"title": "Test",
"type": "object",
"required": ["schema_version", "name"],
"additionalProperties": False,
"properties": {
"schema_version": {
"type": "number"
},
"name": {
"type": "string"
}
}
}
blob = createBlob(dict(
schema_version=1,
name="foo",
))
blob.validate('fake', [])
blob = createBlob(dict(
schema_version=1,
name="foo",
))
blob.validate('fake', [])
self.assertEquals(yaml_load.call_count, 1)
def testSchemaCaching(self):
with mock.patch("yaml.load") as yaml_load:
yaml_load.return_value = {
"title": "Test",
"type": "object",
"required": ["schema_version", "name"],
"additionalProperties": False,
"properties": {
"schema_version": {
"type": "number"
},
"name": {
"type": "string"
}
}
}
blob = createBlob(dict(
schema_version=1,
name="foo",
))
blob.validate()
blob = createBlob(dict(
schema_version=1,
name="foo",
))
blob.validate()
self.assertEquals(yaml_load.call_count, 1)
def _post(self, transaction, changed_by):
sc = connexion.request.get_json()
if sc.get("when", None) is None:
return problem(
400, "Bad Request",
"'when' cannot be set to null when scheduling a new change "
"for a Release")
change_type = sc.get("change_type")
what = {}
for field in sc:
if field == "csrf_token":
continue
what[field] = sc[field]
if change_type == "update":
if not what.get("data_version", None):
return problem(400,
"Bad Request",
"Missing field",
ext={"exception": "data_version is missing"})
data = what.get("data", None)
if data:
what["data"] = createBlob(data)
if "read_only" in what and not data:
what["data"] = self.table.getReleaseBlob(what["name"])
elif change_type == "insert":
if not what.get("product", None):
return problem(400,
"Bad Request",
"Missing field",
ext={"exception": "product is missing"})
if what.get("data", None):
what["data"] = createBlob(what.get("data"))
else:
return problem(400,
"Bad Request",
"Missing field",
ext={"exception": "Missing blob 'data' value"})
elif change_type == "delete":
if not what.get("data_version", None):
return problem(400,
"Bad Request",
"Missing field",
ext={"exception": "data_version is missing"})
try:
return super(ReleaseScheduledChangesView,
self)._post(what, transaction, changed_by,
change_type)
except ReadOnlyError as e:
msg = f"Failed to schedule change - {e}"
return problem(400, "Bad Request", msg, ext={"data": e.args})
def setUp(self):
dbo.setDb('sqlite:///:memory:')
dbo.create()
dbo.releases.t.insert().execute(
name='b', product='b', data_version=1,
data=createBlob({"name": "b", "extv": "1.0", "schema_version": 1, "platforms": {"a": {"buildID": "1", "locales": {"a": {}}}}}))
dbo.releases.t.insert().execute(
name='fallback', product='c', data_version=1,
data=createBlob({"name": "fallback", "extv": "1.0", "schema_version": 1, "platforms": {"a": {"buildID": "1", "locales": {"a": {}}}}}))
def testLocalePutWithCopy(self):
data = json.dumps({
"partial": {
"filesize": 123,
"from": "b",
"hashValue": "abc",
}
})
data = dict(data=data, product='a', copyTo=json.dumps(['ab']), data_version=1, schema_version=1)
ret = self._put('/releases/a/builds/p/l', data=data)
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'a').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "a",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"l": {
"partial": {
"filesize": 123,
"from": "b",
"hashValue": "abc"
}
}
}
}
}
}
"""))
ret = select([dbo.releases.data]).where(dbo.releases.name == 'ab').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "ab",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"l": {
"partial": {
"filesize": 123,
"from": "b",
"hashValue": "abc"
}
}
}
}
}
}
"""))
def _post(self, transaction, changed_by):
change_type = request.json.get("change_type")
if change_type == "update":
form = ScheduledChangeExistingReleaseForm()
form.data.data = createBlob(form.data.data)
elif change_type == "insert":
form = ScheduledChangeNewReleaseForm()
form.data.data = createBlob(form.data.data)
elif change_type == "delete":
form = ScheduledChangeDeleteReleaseForm()
else:
return Response(status=400, response="Invalid or missing change_type")
return super(ReleaseScheduledChangesView, self)._post(form, transaction, changed_by)
def _post(self, changed_by, transaction):
if dbo.releases.getReleaseInfo(names=[connexion.request.get_json().get("name")], transaction=transaction, nameOnly=True, limit=1):
return problem(
400,
"Bad Request",
"Release: %s already exists" % connexion.request.get_json().get("name"),
ext={"data": "Database already contains the release"},
)
try:
blob = createBlob(connexion.request.get_json().get("blob"))
name = dbo.releases.insert(
changed_by=changed_by,
transaction=transaction,
name=connexion.request.get_json().get("name"),
product=connexion.request.get_json().get("product"),
data=blob,
)
except BlobValidationError as e:
msg = "Couldn't create release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't create release", ext={"data": e.errors})
except ValueError as e:
msg = "Couldn't create release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't create release", ext={"data": e.args})
release = dbo.releases.getReleases(name=name, transaction=transaction, limit=1)[0]
return Response(status=201, response=json.dumps(dict(new_data_version=release["data_version"])))
def _post(self, changed_by, transaction):
form = CompleteReleaseForm()
if not form.validate():
self.log.warning("Bad input: %s", form.errors)
return Response(status=400, response=json.dumps(form.errors))
try:
blob = createBlob(form.blob.data)
name = dbo.releases.addRelease(name=form.name.data,
product=form.product.data,
blob=blob,
changed_by=changed_by,
transaction=transaction)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400,
response=json.dumps({"data": e.errors}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.args}))
release = dbo.releases.getReleases(name=name,
transaction=transaction,
limit=1)[0]
new_data_version = release['data_version']
response = make_response(
json.dumps(dict(new_data_version=new_data_version)), 201)
response.headers['Content-Type'] = 'application/json'
return response
def setUp(self):
dbo.setDb("sqlite:///:memory:")
self.metadata.create_all(dbo.engine)
dbo.releases.t.insert().execute(
name="b",
product="b",
data_version=1,
data=createBlob({"name": "b", "extv": "1.0", "schema_version": 1, "platforms": {"a": {"buildID": "1", "locales": {"a": {}}}}}),
)
dbo.releases.t.insert().execute(
name="fallback",
product="c",
data_version=1,
data=createBlob({"name": "fallback", "extv": "1.0", "schema_version": 1, "platforms": {"a": {"buildID": "1", "locales": {"a": {}}}}}),
)
def _post(self, sc_id, transaction, changed_by):
# TODO: modify UI and clients to stop sending 'change_type' in request body
sc_release = self.sc_table.select(where={"sc_id": sc_id}, transaction=transaction, columns=["change_type"])
if sc_release:
change_type = sc_release[0]["change_type"]
else:
return problem(404, "Not Found", "Unknown sc_id",
ext={"exception": "No scheduled change for release found for given sc_id"})
what = {}
for field in connexion.request.get_json():
# Only data may be changed when editing an existing Scheduled Change for
# an existing Release. Name cannot be changed because it is a PK field, and product
# cannot be changed because it almost never makes sense to (and can be done
# by deleting/recreating instead).
# Any Release field may be changed when editing an Scheduled Change for a new Release
if ((change_type == "delete" and field not in ["when", "data_version"]) or
(change_type == "update" and field not in ["when", "data", "data_version"]) or
(change_type == "insert" and field not in ["when", "name", "product", "data"])):
continue
what[field] = connexion.request.get_json()[field]
if change_type in ["update", "delete"] and not what.get("data_version", None):
return problem(400, "Bad Request", "Missing field", ext={"exception": "data_version is missing"})
elif change_type == "insert" and 'data' in what and not what.get("data", None):
# edit scheduled change for new release
return problem(400, "Bad Request", "Null/Empty Value",
ext={"exception": "data cannot be set to null when scheduling insertion of a new release"})
if what.get("data", None):
what["data"] = createBlob(what.get("data"))
return super(ReleaseScheduledChangeView, self)._post(sc_id, what, transaction, changed_by,
connexion.request.get_json().get("sc_data_version", None))
def _post(self, release, transaction, changed_by):
releases = dbo.releases.getReleases(name=release)
if not releases:
return Response(status=404, response='bad release')
change_id = None
if request.json:
change_id = request.json.get('change_id')
if not change_id:
self.log.warning("Bad input: %s", release)
return Response(status=400, response='no change_id')
change = dbo.releases.history.getChange(change_id=change_id)
if change is None:
return Response(status=400, response='bad change_id')
if change['name'] != release:
return Response(status=400, response='bad release')
release = releases[0]
old_data_version = release['data_version']
# now we're going to make a new update based on this change
blob = createBlob(change['data'])
try:
dbo.releases.update(where={"name": change["name"]}, what={"data": blob, "product": change["product"]}, changed_by=changed_by,
old_data_version=old_data_version, transaction=transaction)
except BlobValidationError as e:
self.log.warning("Bad input: %s", e.args)
return Response(status=400, response=json.dumps({"data": e.errors}))
except ValueError as e:
self.log.warning("Bad input: %s", e.args)
return Response(status=400, response=json.dumps({"data": e.args}))
return Response("Excellent!")
def _post(self, release, transaction, changed_by):
change_id = request.form.get('change_id')
if not change_id:
cef_event("Bad input", CEF_WARN, errors="no change id", release=release)
return Response(status=400, response='no change_id')
change = dbo.releases.history.getChange(change_id=change_id)
if change is None:
return Response(status=404, response='bad change_id')
if change['name'] != release:
return Response(status=404, response='bad release')
releases = dbo.releases.getReleases(name=release)
if not releases:
return Response(status=404, response='bad release')
release = releases[0]
if not dbo.permissions.hasUrlPermission(changed_by, '/releases/:name', 'POST', urlOptions={'product': release['product']}):
msg = "%s is not allowed to alter %s releases" % (changed_by, release['product'])
cef_event('Unauthorized access attempt', CEF_ALERT, msg=msg)
return Response(status=401, response=msg)
old_data_version = release['data_version']
# now we're going to make a new update based on this change
blob = createBlob(change['data'])
try:
dbo.releases.updateRelease(changed_by=changed_by, name=change['name'],
version=change['version'], blob=blob,
old_data_version=old_data_version, transaction=transaction)
except ValueError, e:
cef_event("Bad input", CEF_WARN, errors=e.args)
return Response(status=400, response=e.args)
def testReleasePostUpdateExisting(self):
data = json.dumps(dict(detailsUrl='blah', fakePartials=True, schema_version=1))
ret = self._post('/releases/d', data=dict(data=data, product='d', data_version=1))
self.assertStatusCode(ret, 200)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'd').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "d",
"schema_version": 1,
"detailsUrl": "blah",
"fakePartials": true,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"d": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}
"""))
def _post(self, changed_by, transaction):
form = CompleteReleaseForm()
if not form.validate():
self.log.warning("Bad input: %s", form.errors)
return Response(status=400, response=json.dumps(form.errors))
try:
blob = createBlob(form.blob.data)
name = dbo.releases.insert(changed_by=changed_by,
transaction=transaction,
name=form.name.data,
product=form.product.data,
data=blob)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400,
response=json.dumps({"data": e.errors}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.args}))
release = dbo.releases.getReleases(name=name,
transaction=transaction,
limit=1)[0]
return Response(status=201,
response=json.dumps(
dict(new_data_version=release["data_version"])))
def _post(self, release, transaction, changed_by):
change_id = request.form.get('change_id')
if not change_id:
cef_event("Bad input", CEF_WARN, errors="no change id", release=release)
return Response(status=400, response='no change_id')
change = dbo.releases.history.getChange(change_id=change_id)
if change is None:
return Response(status=404, response='bad change_id')
if change['name'] != release:
return Response(status=404, response='bad release')
releases = dbo.releases.getReleases(name=release)
if not releases:
return Response(status=404, response='bad release')
release = releases[0]
if not dbo.permissions.hasUrlPermission(changed_by, '/releases/:name', 'POST', urlOptions={'product': release['product']}):
msg = "%s is not allowed to alter %s releases" % (changed_by, release['product'])
cef_event('Unauthorized access attempt', CEF_ALERT, msg=msg)
return Response(status=401, response=msg)
old_data_version = release['data_version']
# now we're going to make a new update based on this change
blob = createBlob(change['data'])
try:
dbo.releases.updateRelease(changed_by=changed_by, name=change['name'],
version=change['version'], blob=blob,
old_data_version=old_data_version, transaction=transaction)
except ValueError, e:
cef_event("Bad input", CEF_WARN, errors=e.args)
return Response(status=400, response=e.args)
def _post(self, changed_by, transaction):
if dbo.releases.getReleaseInfo(names=[connexion.request.get_json().get("name")], transaction=transaction, nameOnly=True, limit=1):
return problem(
400,
"Bad Request",
"Release: %s already exists" % connexion.request.get_json().get("name"),
ext={"data": "Database already contains the release"},
)
try:
blob = createBlob(connexion.request.get_json().get("blob"))
name = dbo.releases.insert(
changed_by=changed_by,
transaction=transaction,
name=connexion.request.get_json().get("name"),
product=connexion.request.get_json().get("product"),
data=blob,
)
except BlobValidationError as e:
msg = "Couldn't create release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't create release", ext={"data": e.errors})
except ValueError as e:
msg = "Couldn't create release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't create release", ext={"data": e.args})
release = dbo.releases.getReleases(name=name, transaction=transaction, limit=1)[0]
return Response(status=201, response=json.dumps(dict(new_data_version=release["data_version"])))
def testLocalePutForNewRelease(self):
data = json.dumps({
"complete": {
"filesize": 678,
"from": "*",
"hashValue": "abc",
}
})
# setting schema_version in the incoming blob is a hack for testing
# SingleLocaleView._put() doesn't give us access to the form
ret = self._put('/releases/e/builds/p/a', data=dict(data=data, product='e', hashFunction="sha512", schema_version=1))
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'e').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "e",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"a": {
"complete": {
"filesize": 678,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}
"""))
def testLocalePutSpecificPermission(self):
data = json.dumps({
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc",
}
})
ret = self._put('/releases/a/builds/p/l', username="******", data=dict(data=data, product='a', data_version=1, schema_version=1))
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'a').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "a",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"l": {
"complete": {
"filesize": 435,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}
"""))
def testLoadDict(self):
data = dict(
schema_version=1,
name="foo"
)
blob = createBlob(data)
self.assertEquals(blob, data)
def _post(self, changed_by, transaction):
form = CompleteReleaseForm()
if not form.validate():
self.log.warning("Bad input: %s", form.errors)
return Response(status=400, response=json.dumps(form.errors))
try:
blob = createBlob(form.blob.data)
name = dbo.releases.addRelease(
name=form.name.data, product=form.product.data,
blob=blob,
changed_by=changed_by, transaction=transaction
)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.errors}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.args}))
release = dbo.releases.getReleases(
name=name, transaction=transaction, limit=1
)[0]
new_data_version = release['data_version']
response = make_response(
json.dumps(dict(new_data_version=new_data_version)),
201
)
response.headers['Content-Type'] = 'application/json'
return response
def testLoadDict(self):
data = dict(
schema_version=1,
name="foo"
)
blob = createBlob(data)
self.assertEquals(blob, data)
def _post(self, release, transaction, changed_by):
releases = dbo.releases.getReleases(name=release)
if not releases:
return Response(status=404, response='bad release')
change_id = None
if request.json:
change_id = request.json.get('change_id')
if not change_id:
self.log.warning("Bad input: %s", release)
return Response(status=400, response='no change_id')
change = dbo.releases.history.getChange(change_id=change_id)
if change is None:
return Response(status=400, response='bad change_id')
if change['name'] != release:
return Response(status=400, response='bad release')
release = releases[0]
old_data_version = release['data_version']
# now we're going to make a new update based on this change
blob = createBlob(change['data'])
try:
dbo.releases.update(where={"name": change["name"]}, what={"data": blob, "product": change["product"]}, changed_by=changed_by,
old_data_version=old_data_version, transaction=transaction)
except BlobValidationError as e:
self.log.warning("Bad input: %s", e.args)
return Response(status=400, response=json.dumps({"data": e.errors}))
except ValueError as e:
self.log.warning("Bad input: %s", e.args)
return Response(status=400, response=json.dumps({"data": e.args}))
return Response("Excellent!")
def _put(self, release, changed_by, transaction):
form = CompleteReleaseForm()
if not form.validate():
cef_event("Bad input", CEF_WARN, errors=form.errors)
return Response(status=400, response=form.errors)
blob = createBlob(form.blob.data)
if dbo.releases.getReleases(name=release, limit=1):
data_version = form.data_version.data
try:
dbo.releases.updateRelease(name=release, blob=blob, version=form.version.data,
product=form.product.data, changed_by=changed_by,
old_data_version=data_version, transaction=transaction)
except ValueError as e:
msg = "Couldn't update release: %s" % e
cef_event("Bad input", CEF_WARN, errors=msg)
return Response(status=400, response=msg)
data_version += 1
return Response(json.dumps(dict(new_data_version=data_version)), status=200)
else:
try:
dbo.releases.addRelease(name=release, product=form.product.data,
version=form.version.data, blob=blob,
changed_by=changed_by, transaction=transaction)
except ValueError as e:
msg = "Couldn't update release: %s" % e
cef_event("Bad input", CEF_WARN, errors=msg)
return Response(status=400, response=msg)
return Response(status=201)
def createRelease(release, product, changed_by, transaction, releaseData):
blob = createBlob(releaseData)
dbo.releases.insert(changed_by=changed_by,
transaction=transaction,
name=release,
product=product,
data=blob)
return dbo.releases.getReleases(name=release, transaction=transaction)[0]
def createRelease(release, product, changed_by, transaction, releaseData):
blob = createBlob(json.dumps(releaseData))
dbo.releases.addRelease(name=release,
product=product,
blob=blob,
changed_by=changed_by,
transaction=transaction)
return dbo.releases.getReleases(name=release, transaction=transaction)[0]
def _put(self, release, changed_by, transaction):
if dbo.releases.getReleases(name=release, limit=1):
if not connexion.request.get_json().get("data_version"):
return problem(400, "Bad Request", "data_version field is missing")
try:
blob = createBlob(connexion.request.get_json().get("blob"))
dbo.releases.update(
where={"name": release},
what={"data": blob, "product": connexion.request.get_json().get("product")},
changed_by=changed_by,
old_data_version=connexion.request.get_json().get("data_version"),
transaction=transaction,
)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't update release", ext={"data": e.errors})
except ReadOnlyError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(403, "Forbidden", "Couldn't update release. Release is marked read only", ext={"data": e.args})
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't update release", ext={"data": e.args})
# the data_version might jump by more than 1 if outdated blobs are
# merged
data_version = dbo.releases.getReleases(name=release, transaction=transaction)[0]["data_version"]
return jsonify(new_data_version=data_version)
else:
try:
blob = createBlob(connexion.request.get_json().get("blob"))
dbo.releases.insert(
changed_by=changed_by, transaction=transaction, name=release, product=connexion.request.get_json().get("product"), data=blob
)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't update release", ext={"data": e.errors})
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't update release", ext={"data": e.args})
return Response(status=201)
def _put(self, release, changed_by, transaction):
if dbo.releases.getReleases(name=release, limit=1):
if not connexion.request.get_json().get("data_version"):
return problem(400, "Bad Request", "data_version field is missing")
try:
blob = createBlob(connexion.request.get_json().get("blob"))
dbo.releases.update(
where={"name": release},
what={"data": blob, "product": connexion.request.get_json().get("product")},
changed_by=changed_by,
old_data_version=connexion.request.get_json().get("data_version"),
transaction=transaction,
)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't update release", ext={"data": e.errors})
except ReadOnlyError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(403, "Forbidden", "Couldn't update release. Release is marked read only", ext={"data": e.args})
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't update release", ext={"data": e.args})
# the data_version might jump by more than 1 if outdated blobs are
# merged
data_version = dbo.releases.getReleases(name=release, transaction=transaction)[0]["data_version"]
return jsonify(new_data_version=data_version)
else:
try:
blob = createBlob(connexion.request.get_json().get("blob"))
dbo.releases.insert(
changed_by=changed_by, transaction=transaction, name=release, product=connexion.request.get_json().get("product"), data=blob
)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't update release", ext={"data": e.errors})
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return problem(400, "Bad Request", "Couldn't update release", ext={"data": e.args})
return Response(status=201)
def _put(self, release, changed_by, transaction):
form = CompleteReleaseForm()
if not form.validate():
self.log.warning("Bad input: %s", form.errors)
return Response(status=400, response=json.dumps(form.errors))
blob = createBlob(form.blob.data)
if dbo.releases.getReleases(name=release, limit=1):
data_version = form.data_version.data
try:
dbo.releases.update(where={"name": release},
what={
"data": blob,
"product": form.product.data
},
changed_by=changed_by,
old_data_version=data_version,
transaction=transaction)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400,
response=json.dumps({"data": e.errors}))
except ReadOnlyError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=403,
response=json.dumps({"data": e.args}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400,
response=json.dumps({"data": e.args}))
# the data_version might jump by more than 1 if outdated blobs are
# merged
data_version = dbo.releases.getReleases(
name=release, transaction=transaction)[0]['data_version']
return jsonify(new_data_version=data_version)
else:
try:
dbo.releases.insert(changed_by=changed_by,
transaction=transaction,
name=release,
product=form.product.data,
data=blob)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400,
response=json.dumps({"data": e.errors}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400,
response=json.dumps({"data": e.args}))
return Response(status=201)
def commit(rel, product, version, newReleaseData, releaseData,
old_data_version, extraArgs):
releaseData.update(newReleaseData)
blob = createBlob(releaseData)
return dbo.releases.updateRelease(
name=rel,
blob=blob,
changed_by=changed_by,
old_data_version=old_data_version,
transaction=transaction)
def commit(rel, product, newReleaseData, releaseData, old_data_version,
extraArgs):
releaseData.update(newReleaseData)
blob = createBlob(releaseData)
return dbo.releases.update(where={"name": rel},
what={
"data": blob,
"product": product
},
changed_by=changed_by,
old_data_version=old_data_version,
transaction=transaction)
def testGMPReleasePut(self):
ret = self._put('/releases/gmprel', data=dict(name='gmprel', product='a',
blob="""
{
"name": "gmprel",
"schema_version": 1000,
"hashFunction": "sha512",
"vendors": {
"foo": {
"version": "1",
"platforms": {
"a": {
"filesize": "2",
"hashValue": "3",
"fileUrl": "http://good.com/4"
},
"a2": {
"alias": "a"
}
}
}
}
}
"""))
self.assertEquals(ret.status_code, 201, "Status Code: %d, Data: %s" % (ret.status_code, ret.data))
r = dbo.releases.t.select().where(dbo.releases.name == 'gmprel').execute().fetchall()
self.assertEquals(len(r), 1)
self.assertEquals(r[0]['name'], 'gmprel')
self.assertEquals(r[0]['product'], 'a')
self.assertEquals(r[0]['data'], createBlob("""
{
"name": "gmprel",
"schema_version": 1000,
"hashFunction": "sha512",
"vendors": {
"foo": {
"version": "1",
"platforms": {
"a": {
"filesize": "2",
"hashValue": "3",
"fileUrl": "http://good.com/4"
},
"a2": {
"alias": "a"
}
}
}
}
}
"""))
def setUp(self):
dbo.setDb("sqlite:///:memory:")
self.metadata.create_all(dbo.engine)
dbo.releases.t.insert().execute(
name="b",
product="b",
data_version=1,
data=createBlob({
"name": "b",
"extv": "1.0",
"schema_version": 1,
"platforms": {
"a": {
"buildID": "1",
"locales": {
"a": {}
}
}
}
}),
)
dbo.releases.t.insert().execute(
name="fallback",
product="c",
data_version=1,
data=createBlob({
"name": "fallback",
"extv": "1.0",
"schema_version": 1,
"platforms": {
"a": {
"buildID": "1",
"locales": {
"a": {}
}
}
}
}),
)
def _post(self, sc_id, transaction, changed_by):
change_type = connexion.request.get_json().get("change_type")
if change_type == "update":
form = EditScheduledChangeExistingReleaseForm()
elif change_type == "insert":
form = EditScheduledChangeNewReleaseForm()
elif change_type == "delete":
form = EditScheduledChangeExistingReleaseForm()
else:
return Response(status=400, response="Invalid or missing change_type")
if form.data.data:
form.data.data = createBlob(form.data.data)
return super(ReleaseScheduledChangeView, self)._post(sc_id, form, transaction, changed_by)
def _put(self, release, changed_by, transaction):
form = NewReleaseForm()
if not form.validate():
cef_event("Bad input", CEF_WARN, errors=form.errors)
return Response(status=400, response=form.errors)
try:
blob = createBlob(form.blob.data)
dbo.releases.addRelease(name=release, product=form.product.data,
version=form.version.data, blob=blob,
changed_by=changed_by, transaction=transaction)
except ValueError, e:
msg = "Couldn't update release: %s" % e
cef_event("Bad input", CEF_WARN, errors=msg)
return Response(status=400, response=msg)
def testLocalePutAppendWithAlias(self):
data = json.dumps({
"partial": {
"filesize": 123,
"from": "c",
"hashValue": "abc",
"fileUrl": "http://good.com/blah",
}
})
ret = self._put('/releases/d/builds/q/g', data=dict(data=data, product='d', data_version=1, alias='["q2"]', schema_version=1))
self.assertStatusCode(ret, 201)
self.assertEqual(ret.data, json.dumps(dict(new_data_version=2)), "Data: %s" % ret.data)
ret = select([dbo.releases.data]).where(dbo.releases.name == 'd').execute().fetchone()[0]
self.assertEqual(ret, createBlob("""
{
"name": "d",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"d": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
},
"q": {
"locales": {
"g": {
"partial": {
"filesize": 123,
"from": "c",
"hashValue": "abc",
"fileUrl": "http://good.com/blah"
}
}
}
},
"q2": {
"alias": "q"
}
}
}
"""))
def _post(self, sc_id, transaction, changed_by):
change_type = connexion.request.get_json().get("change_type")
if change_type == "update":
form = EditScheduledChangeExistingReleaseForm()
elif change_type == "insert":
form = EditScheduledChangeNewReleaseForm()
elif change_type == "delete":
form = EditScheduledChangeExistingReleaseForm()
else:
return Response(status=400,
response="Invalid or missing change_type")
if form.data.data:
form.data.data = createBlob(form.data.data)
return super(ReleaseScheduledChangeView,
self)._post(sc_id, form, transaction, changed_by)
def _put(self, release, changed_by, transaction):
form = CompleteReleaseForm()
if not form.validate():
cef_event("Bad input", CEF_WARN, errors=form.errors)
return Response(status=400, response=json.dumps(form.errors))
blob = createBlob(form.blob.data)
if dbo.releases.getReleases(name=release, limit=1):
data_version = form.data_version.data
try:
dbo.releases.updateRelease(name=release,
blob=blob,
product=form.product.data,
changed_by=changed_by,
old_data_version=data_version,
transaction=transaction)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
cef_event("Bad input", CEF_WARN, errors=msg)
return Response(status=400,
response=json.dumps({"data": e.errors}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
cef_event("Bad input", CEF_WARN, errors=msg)
return Response(status=400,
response=json.dumps({"data": e.args}))
data_version += 1
return Response(json.dumps(dict(new_data_version=data_version)),
status=200)
else:
try:
dbo.releases.addRelease(name=release,
product=form.product.data,
blob=blob,
changed_by=changed_by,
transaction=transaction)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
cef_event("Bad input", CEF_WARN, errors=msg)
return Response(status=400,
response=json.dumps({"data": e.errors}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
cef_event("Bad input", CEF_WARN, errors=msg)
return Response(status=400,
response=json.dumps({"data": e.args}))
return Response(status=201)
def _post(self, release, transaction, changed_by):
change_id = None
if request.json:
change_id = request.json.get('change_id')
if not change_id:
self.log.warning("Bad input: %s", release)
return Response(status=400, response='no change_id')
change = dbo.releases.history.getChange(change_id=change_id)
if change is None:
return Response(status=404, response='bad change_id')
if change['name'] != release:
return Response(status=404, response='bad release')
releases = dbo.releases.getReleases(name=release)
if not releases:
return Response(status=404, response='bad release')
release = releases[0]
if not dbo.permissions.hasUrlPermission(
changed_by,
'/releases/:name',
'POST',
urlOptions={'product': release['product']}):
msg = "%s is not allowed to alter %s releases" % (
changed_by, release['product'])
self.log.warning("Unauthorized access attempt: %s", msg)
return Response(status=401, response=msg)
old_data_version = release['data_version']
# now we're going to make a new update based on this change
blob = createBlob(change['data'])
try:
dbo.releases.updateRelease(changed_by=changed_by,
name=change['name'],
blob=blob,
product=change['product'],
old_data_version=old_data_version,
transaction=transaction)
except BlobValidationError as e:
self.log.warning("Bad input: %s", e.args)
return Response(status=400,
response=json.dumps({"data": e.errors}))
except ValueError as e:
self.log.warning("Bad input: %s", e.args)
return Response(status=400, response=json.dumps({"data": e.args}))
return Response("Excellent!")
def _post(self, changed_by, transaction):
form = CompleteReleaseForm()
if not form.validate():
cef_event("Bad input", CEF_WARN, errors=form.errors)
return Response(status=400, response=json.dumps(form.errors))
try:
blob = createBlob(form.blob.data)
name = dbo.releases.addRelease(
name=form.name.data, product=form.product.data,
version=form.version.data, blob=blob,
changed_by=changed_by, transaction=transaction
)
except ValueError, e:
msg = "Couldn't update release: %s" % e
cef_event("Bad input", CEF_WARN, errors=msg)
return Response(status=400, response=msg)
def testReleasePostCreatesNewReleasev2(self):
data = json.dumps(dict(bouncerProducts=dict(complete='foo'), name='e', hashFunction="sha512"))
ret = self._post('/releases/e', data=dict(data=data, product='e', schema_version=2))
self.assertStatusCode(ret, 201)
ret = dbo.releases.t.select().where(dbo.releases.name == 'e').execute().fetchone()
self.assertEqual(ret['product'], 'e')
self.assertEqual(ret['name'], 'e')
self.assertEqual(ret['data'], createBlob("""
{
"name": "e",
"hashFunction": "sha512",
"schema_version": 2,
"bouncerProducts": {
"complete": "foo"
}
}
"""))
def testReleasesPost(self):
data = json.dumps(dict(bouncerProducts=dict(partial='foo'), name='e', schema_version=1, hashFunction="sha512"))
ret = self._post('/releases', data=dict(blob=data, name="e", product='e'))
self.assertStatusCode(ret, 201)
ret = dbo.releases.t.select().where(dbo.releases.name == 'e').execute().fetchone()
self.assertEqual(ret['product'], 'e')
self.assertEqual(ret['name'], 'e')
self.assertEqual(ret['data'], createBlob("""
{
"name": "e",
"hashFunction": "sha512",
"schema_version": 1,
"bouncerProducts": {
"partial": "foo"
}
}
"""))
def _put(self, release, changed_by, transaction):
form = CompleteReleaseForm()
if not form.validate():
self.log.warning("Bad input: %s", form.errors)
return Response(status=400, response=json.dumps(form.errors))
blob = createBlob(form.blob.data)
if dbo.releases.getReleases(name=release, limit=1):
data_version = form.data_version.data
try:
dbo.releases.updateRelease(name=release, blob=blob,
product=form.product.data, changed_by=changed_by,
old_data_version=data_version, transaction=transaction)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.errors}))
except ReadOnlyError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=403, response=json.dumps({"data": e.args}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.args}))
# the data_version might jump by more than 1 if outdated blobs are
# merged
data_version = dbo.releases.getReleases(name=release, transaction=transaction)[0]['data_version']
return Response(json.dumps(dict(new_data_version=data_version)), status=200)
else:
try:
dbo.releases.addRelease(name=release, product=form.product.data,
blob=blob,
changed_by=changed_by, transaction=transaction)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.errors}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.args}))
return Response(status=201)
def testPutExistingRelease(self):
ret = self._put("/releases/d", data=dict(name="d", product="Firefox", data_version=1, blob="""
{
"name": "d",
"schema_version": 3,
"hashFunction": "sha512",
"actions": "doit"
}
"""))
self.assertEquals(ret.status_code, 200, "Status Code: %d, Data: %s" % (ret.status_code, ret.data))
r = dbo.releases.t.select().where(dbo.releases.name == 'd').execute().fetchall()
self.assertEquals(len(r), 1)
self.assertEquals(r[0]['name'], 'd')
self.assertEquals(r[0]['product'], 'Firefox')
self.assertEquals(r[0]['data'], createBlob("""
{
"name": "d",
"schema_version": 3,
"hashFunction": "sha512",
"actions": "doit"
}
"""))
def testNewReleasePut(self):
ret = self._put('/releases/new_release', data=dict(name='new_release', product='Firefox',
blob="""
{
"name": "new_release",
"hashFunction": "sha512",
"schema_version": 1,
"platforms": {
"p": {
"locales": {
"l": {
}
}
}
}
}
"""))
self.assertEquals(ret.status_code, 201, "Status Code: %d, Data: %s" % (ret.status_code, ret.data))
r = dbo.releases.t.select().where(dbo.releases.name == 'new_release').execute().fetchall()
self.assertEquals(len(r), 1)
self.assertEquals(r[0]['name'], 'new_release')
self.assertEquals(r[0]['product'], 'Firefox')
self.assertEquals(r[0]['data'], createBlob("""
{
"name": "new_release",
"hashFunction": "sha512",
"schema_version": 1,
"platforms": {
"p": {
"locales": {
"l": {
}
}
}
}
}
"""))
def _post(self, release, transaction, changed_by):
change_id = None
if request.json:
change_id = request.json.get('change_id')
if not change_id:
self.log.warning("Bad input: %s", release)
return Response(status=400, response='no change_id')
change = dbo.releases.history.getChange(change_id=change_id)
if change is None:
return Response(status=404, response='bad change_id')
if change['name'] != release:
return Response(status=404, response='bad release')
releases = dbo.releases.getReleases(name=release)
if not releases:
return Response(status=404, response='bad release')
release = releases[0]
if not dbo.permissions.hasUrlPermission(changed_by, '/releases/:name', 'POST', urlOptions={'product': release['product']}):
msg = "%s is not allowed to alter %s releases" % (changed_by, release['product'])
self.log.warning("Unauthorized access attempt: %s", msg)
return Response(status=401, response=msg)
old_data_version = release['data_version']
# now we're going to make a new update based on this change
blob = createBlob(change['data'])
try:
dbo.releases.updateRelease(changed_by=changed_by, name=change['name'],
blob=blob, product=change['product'],
old_data_version=old_data_version, transaction=transaction)
except BlobValidationError as e:
self.log.warning("Bad input: %s", e.args)
return Response(status=400, response=json.dumps({"data": e.errors}))
except ValueError as e:
self.log.warning("Bad input: %s", e.args)
return Response(status=400, response=json.dumps({"data": e.args}))
return Response("Excellent!")
def _post(self, changed_by, transaction):
form = CompleteReleaseForm()
if not form.validate():
self.log.warning("Bad input: %s", form.errors)
return Response(status=400, response=json.dumps(form.errors))
try:
blob = createBlob(form.blob.data)
name = dbo.releases.insert(changed_by=changed_by, transaction=transaction,
name=form.name.data, product=form.product.data,
data=blob)
except BlobValidationError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.errors}))
except ValueError as e:
msg = "Couldn't update release: %s" % e
self.log.warning("Bad input: %s", msg)
return Response(status=400, response=json.dumps({"data": e.args}))
release = dbo.releases.getReleases(
name=name, transaction=transaction, limit=1
)[0]
return Response(status=201, response=json.dumps(dict(new_data_version=release["data_version"])))
def commit(rel, product, newReleaseData, releaseData, old_data_version, extraArgs):
releaseData.update(newReleaseData)
blob = createBlob(releaseData)
return dbo.releases.update(where={"name": rel}, what={"data": blob, "product": product},
changed_by=changed_by, old_data_version=old_data_version,
transaction=transaction)
def setUp(self):
app.config["DEBUG"] = True
app.config["SPECIAL_FORCE_HOSTS"] = ("http://a.com",)
app.config["WHITELISTED_DOMAINS"] = {"a.com": ("a", "b", "c")}
dbo.setDb("sqlite:///:memory:")
dbo.create()
self.client = app.test_client()
dbo.setDomainWhitelist({"a.com": ("a", "b", "c")})
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping="a", update_type="minor", product="a",
data_version=1)
dbo.releases.t.insert().execute(name="a", product="a", data_version=1, data=createBlob("""
{
"name": "a",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "2",
"locales": {
"l": {
"complete": {
"filesize": "3",
"from": "*",
"hashValue": "4",
"fileUrl": "http://a.com/z"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping="b", update_type="minor", product="b",
mig64=True, data_version=1)
dbo.releases.t.insert().execute(name="b", product="b", data_version=1, data=createBlob("""
{
"name": "b",
"schema_version": 1,
"appv": "2.0",
"extv": "2.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "12",
"locales": {
"l": {
"complete": {
"filesize": "13",
"from": "*",
"hashValue": "14",
"fileUrl": "http://a.com/z1"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping="c", update_type="minor", product="c",
mig64=False, data_version=1)
dbo.releases.t.insert().execute(name="c", product="c", data_version=1, data=createBlob("""
{
"name": "c",
"schema_version": 1,
"appv": "3.0",
"extv": "3.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "22",
"locales": {
"l": {
"complete": {
"filesize": "23",
"from": "*",
"hashValue": "24",
"fileUrl": "http://a.com/z2"
}
}
}
}
}
}
"""))
def _get_what(self, change):
return dict(data=createBlob(change['data']), product=change["product"])
def setUp(self):
self.version_fd, self.version_file = mkstemp()
app.config['DEBUG'] = True
app.config['SPECIAL_FORCE_HOSTS'] = ('http://a.com',)
app.config['WHITELISTED_DOMAINS'] = {'a.com': ('b', 'c', 'e', 'f', 'response-a', 'response-b', 's', 'responseblob-a',
'responseblob-b', 'q', 'fallback')}
app.config["VERSION_FILE"] = self.version_file
with open(self.version_file, "w+") as f:
f.write("""
{
"source":"https://github.com/mozilla/balrog",
"version":"1.0",
"commit":"abcdef123456"
}
""")
dbo.setDb('sqlite:///:memory:')
dbo.create()
dbo.setDomainWhitelist({'a.com': ('b', 'c', 'e')})
self.client = app.test_client()
dbo.permissions.t.insert().execute(permission='admin', username='******', data_version=1)
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping='b', update_type='minor', product='b',
data_version=1, alias="moz-releng")
dbo.releases.t.insert().execute(name='b', product='b', data_version=1, data=createBlob("""
{
"name": "b",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "2",
"locales": {
"l": {
"complete": {
"filesize": "3",
"from": "*",
"hashValue": "4",
"fileUrl": "http://a.com/z"
}
},
"xh": {
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "6",
"fileUrl": "http://a.com/x"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping='s', update_type='minor', product='s',
instructionSet="SSE", data_version=1)
dbo.releases.t.insert().execute(name='s', product='s', data_version=1, data=createBlob("""
{
"name": "s",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "5",
"locales": {
"l": {
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "5",
"fileUrl": "http://a.com/s"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=90, backgroundRate=0, mapping='q', update_type='minor', product='q',
fallbackMapping='fallback', data_version=1)
dbo.releases.t.insert().execute(name='q', product='q', data_version=1, data=createBlob("""
{
"name": "q",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "5",
"locales": {
"l": {
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "5",
"fileUrl": "http://a.com/q"
}
}
}
}
}
}
"""))
dbo.releases.t.insert().execute(name='fallback', product='q', data_version=1, data=createBlob("""
{
"name": "fallback",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "5",
"locales": {
"l": {
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "5",
"fileUrl": "http://a.com/fallback"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping='c', update_type='minor', product='c',
distribution='default', data_version=1)
dbo.releases.t.insert().execute(name='c', product='c', data_version=1, data=createBlob("""
{
"name": "c",
"schema_version": 1,
"appv": "10.0",
"extv": "10.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "11",
"locales": {
"l": {
"complete": {
"filesize": "12",
"from": "*",
"hashValue": "13",
"fileUrl": "http://a.com/y"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping='d', update_type='minor', product='d', data_version=1)
dbo.releases.t.insert().execute(name='d', product='d', data_version=1, data=createBlob("""
{
"name": "d",
"schema_version": 1,
"appv": "20.0",
"extv": "20.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "21",
"locales": {
"l": {
"complete": {
"filesize": 22,
"from": "*",
"hashValue": "23",
"fileUrl": "http://evil.com/y"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=90, backgroundRate=0, mapping='e', update_type='minor', product='e', data_version=1)
dbo.releases.t.insert().execute(name='e', product='e', data_version=1, data=createBlob("""
{
"name": "e",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "25",
"locales": {
"l": {
"complete": {
"filesize": 22,
"from": "*",
"hashValue": "23",
"fileUrl": "http://a.com/y"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping="f", update_type="minor", product="f",
channel="a", memory="<=8000", data_version=1)
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping="f", update_type="minor", product="f",
channel="b", memory="9000", data_version=1)
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping="f", update_type="minor", product="f",
channel="c", memory=">10000", data_version=1)
dbo.releases.t.insert().execute(name="f", product="f", data_version=1, data=createBlob("""
{
"name": "f",
"schema_version": 1,
"hashFunction": "sha512",
"appv": "1.0",
"extv": "1.0",
"platforms": {
"p": {
"buildID": "35",
"locales": {
"l": {
"complete": {
"filesize": 33,
"from": "*",
"hashValue": "34",
"fileUrl": "http://a.com/f"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=200, backgroundRate=100,
mapping='gmp', update_type='minor',
product='gmp',
data_version=1)
dbo.rules.t.insert().execute(priority=200, backgroundRate=100,
mapping='gmp-with-one-response-product', update_type='minor',
product='gmp-with-one-response-product',
data_version=1)
dbo.rules.t.insert().execute(priority=190, backgroundRate=100,
mapping='response-a', update_type='minor',
product='response-a',
data_version=1)
dbo.rules.t.insert().execute(priority=180, backgroundRate=100,
mapping='response-b', update_type='minor',
product='response-b', data_version=1)
dbo.releases.t.insert().execute(name='gmp-with-one-response-product',
product='gmp-with-one-response-product', data_version=1, data=createBlob("""
{
"name": "superblob",
"schema_version": 4000,
"products": ["response-a"]
}
"""))
dbo.releases.t.insert().execute(name='gmp', product='gmp', data_version=1, data=createBlob("""
{
"name": "superblob",
"schema_version": 4000,
"products": ["response-a", "response-b"]
}
"""))
dbo.releases.t.insert().execute(name='response-a', product='response-a', data_version=1, data=createBlob("""
{
"name": "response-a",
"schema_version": 1,
"extv": "2.5",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "25",
"locales": {
"l": {
"complete": {
"filesize": 22,
"from": "*",
"hashValue": "23",
"fileUrl": "http://a.com/public"
}
}
}
},
"q": {
"buildID": "25",
"locales": {
"l": {
"complete": {
"filesize": 22,
"from": "*",
"hashValue": "23",
"fileUrl": "http://a.com/public-q"
}
}
}
}
}
}
"""))
dbo.releases.t.insert().execute(name='response-b', product='response-b', data_version=1, data=createBlob("""
{
"name": "response-b",
"schema_version": 1,
"extv": "2.5",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "25",
"locales": {
"l": {
"complete": {
"filesize": 27777777,
"from": "*",
"hashValue": "23",
"fileUrl": "http://a.com/b"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=180, backgroundRate=100,
mapping='systemaddons-uninstall', update_type='minor',
product='systemaddons-uninstall', data_version=1)
dbo.releases.t.insert().execute(name='systemaddons-uninstall',
product='systemaddons-uninstall', data_version=1, data=createBlob("""
{
"name": "fake",
"schema_version": 5000,
"hashFunction": "SHA512",
"uninstall": true
}
"""))
dbo.rules.t.insert().execute(priority=180, backgroundRate=100,
mapping='systemaddons', update_type='minor',
product='systemaddons', data_version=1)
dbo.releases.t.insert().execute(name='systemaddons',
product='systemaddons', data_version=1, data=createBlob("""
{
"name": "fake",
"schema_version": 5000,
"hashFunction": "SHA512",
"uninstall": false,
"addons": {
"c": {
"version": "1",
"platforms": {
"p": {
"filesize": 2,
"hashValue": "3",
"fileUrl": "http://a.com/blah"
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=1000, backgroundRate=0, mapping='product_that_should_not_be_updated-1.1',
update_type='minor', product='product_that_should_not_be_updated',
data_version=1)
dbo.releases.t.insert().execute(name='product_that_should_not_be_updated-1.1', product='product_that_should_not_be_updated', data_version=1, data=createBlob("""
{
"name": "product_that_should_not_be_updated-1.1",
"schema_version": 1,
"appv": "1.1",
"extv": "1.1",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "2",
"locales": {
"l": {
"complete": {
"filesize": "3",
"from": "*",
"hashValue": "4",
"fileUrl": "http://a.com/z"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=90, backgroundRate=100, mapping='product_that_should_not_be_updated-2.0',
update_type='minor', product='product_that_should_not_be_updated',
data_version=1)
dbo.releases.t.insert().execute(name='product_that_should_not_be_updated-2.0', product='product_that_should_not_be_updated', data_version=1, data=createBlob("""
{
"name": "product_that_should_not_be_updated-2.0",
"schema_version": 1,
"appv": "2.0",
"extv": "2.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "2",
"locales": {
"l": {
"complete": {
"filesize": "3",
"from": "*",
"hashValue": "4",
"fileUrl": "http://a.com/z"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(priority=200, backgroundRate=100,
mapping='superblobaddon-with-multiple-response-blob', update_type='minor',
product='superblobaddon-with-multiple-response-blob',
data_version=1)
dbo.rules.t.insert().execute(priority=200, backgroundRate=100,
mapping='superblobaddon-with-one-response-blob', update_type='minor',
product='superblobaddon-with-one-response-blob',
data_version=1)
dbo.releases.t.insert().execute(name='superblobaddon-with-one-response-blob',
product='superblobaddon-with-one-response-blob', data_version=1, data=createBlob("""
{
"name": "superblobaddon",
"schema_version": 4000,
"blobs": ["responseblob-a"]
}
"""))
dbo.releases.t.insert().execute(name='superblobaddon-with-multiple-response-blob',
product='superblobaddon-with-multiple-response-blob', data_version=1, data=createBlob("""
{
"name": "superblobaddon",
"schema_version": 4000,
"blobs": ["responseblob-a", "responseblob-b"]
}
"""))
dbo.releases.t.insert().execute(name='responseblob-a', product='responseblob-a', data_version=1, data=createBlob("""
{
"name": "responseblob-a",
"schema_version": 5000,
"hashFunction": "SHA512",
"addons": {
"c": {
"version": "1",
"platforms": {
"p": {
"filesize": 2,
"hashValue": "3",
"fileUrl": "http://a.com/e"
},
"q": {
"filesize": 4,
"hashValue": "5",
"fileUrl": "http://a.com/e"
},
"q2": {
"alias": "q"
}
}
},
"d": {
"version": "5",
"platforms": {
"q": {
"filesize": 10,
"hashValue": "11",
"fileUrl": "http://a.com/c"
},
"default": {
"filesize": 20,
"hashValue": "50",
"fileUrl": "http://a.com/c"
}
}
}
}
}
"""))
dbo.releases.t.insert().execute(name='responseblob-b', product='responseblob-b', data_version=1, data=createBlob("""
{
"name": "responseblob-b",
"schema_version": 5000,
"hashFunction": "sha512",
"uninstall": false,
"addons": {
"b": {
"version": "1",
"platforms": {
"p": {
"filesize": 27,
"hashValue": "23",
"fileUrl": "http://a.com/b"
}
}
}
}
}
"""))
def testLoadString(self):
data = """{
"schema_version": 2,
"name": "blah"}"""
blob = createBlob(data)
self.assertEquals(blob, dict(schema_version=2, name="blah"))
def setUp(self):
app.config['DEBUG'] = True
self.public_client = app.test_client()
dbo.setDb('sqlite:///:memory:')
dbo.create()
dbo.rules.t.insert().execute(rule_id=1,
priority=90,
backgroundRate=100,
mapping='Fennec.55.0a1',
update_type='minor',
product='Fennec',
data_version=1,
alias="moz-releng")
dbo.releases.t.insert().execute(name='Fennec.55.0a1',
product='Fennec',
data_version=1,
data=createBlob("""
{
"name": "Fennec.55.0a1",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "2",
"locales": {
"l": {
"complete": {
"filesize": "3",
"from": "*",
"hashValue": "4",
"fileUrl": "http://a.com/z"
}
},
"xh": {
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "6",
"fileUrl": "http://a.com/x"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(rule_id=2,
priority=90,
backgroundRate=100,
mapping='Firefox.55.0a1',
update_type='minor',
product='Firefox',
systemCapabilities="SSE",
data_version=1)
dbo.releases.t.insert().execute(name='Firefox.55.0a1',
product='Firefox',
data_version=1,
data=createBlob("""
{
"name": "Firefox.55.0a1",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "5",
"locales": {
"l": {
"buildID": "5",
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "5",
"fileUrl": "http://a.com/s"
}
}
}
}
}
}
"""))
dbo.rules.t.insert().execute(rule_id=3,
priority=90,
backgroundRate=0,
mapping='q',
update_type='minor',
product='q',
data_version=3)
dbo.rules.history.t.insert().execute(change_id=1,
changed_by="usr",
timestamp=10,
rule_id=3,
priority=90,
backgroundRate=0,
mapping='y',
update_type='minor',
product='y',
data_version=2)
dbo.rules.history.t.insert().execute(change_id=2,
changed_by="usr",
timestamp=10,
rule_id=3,
priority=90,
backgroundRate=0,
mapping='z',
update_type='minor',
product='z',
data_version=1)
dbo.releases.t.insert().execute(name='q',
product='q',
data_version=2,
data=createBlob("""
{
"name": "q",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "6",
"locales": {
"l": {
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "5",
"fileUrl": "http://a.com/q"
}
}
}
}
}
}
"""))
dbo.releases.history.t.insert().execute(change_id=1,
changed_by="usr",
timestamp=10,
name='q',
product='q',
data_version=1)
def setUp(self):
from auslib.web.admin.views import base as view_base
self.view_base = view_base
# Mock out verified_userinfo, because we don't want to talk to Auth0
# or need to provide real credentials in tests.
# We don't do this with "mock" because this is a base to all of other
# tests, and "mock" must be applied in the tests itself.
self.orig_base_verified_userinfo = view_base.verified_userinfo
self.mocked_user = None
def my_userinfo(*args, **kwargs):
return {"email": self.mocked_user}
view_base.verified_userinfo = my_userinfo
self.version_fd, self.version_file = mkstemp()
cache.reset()
cache.make_copies = True
app.config["SECRET_KEY"] = "abc123"
app.config["DEBUG"] = True
app.config["WTF_CSRF_ENABLED"] = False
app.config["WHITELISTED_DOMAINS"] = {"good.com": ("a", "b", "c", "d")}
app.config["VERSION_FILE"] = self.version_file
app.config["AUTH_DOMAIN"] = "balrog.test.dev"
app.config["AUTH_AUDIENCE"] = "balrog test"
app.config["M2M_ACCOUNT_MAPPING"] = {}
app.config["CORS_ORIGINS"] = "*"
with open(self.version_file, "w+") as f:
f.write("""
{
"source":"https://github.com/mozilla/balrog",
"version":"1.0",
"commit":"abcdef123456"
}
""")
dbo.setDb("sqlite:///:memory:")
dbo.setDomainWhitelist({"good.com": ("a", "b", "c", "d")})
self.metadata.create_all(dbo.engine)
dbo.permissions.t.insert().execute(permission="admin",
username="******",
data_version=1)
dbo.permissions.t.insert().execute(permission="permission",
username="******",
data_version=1)
dbo.permissions.t.insert().execute(permission="release",
username="******",
options=dict(
products=["fake", "a", "b"],
actions=["create", "modify"]),
data_version=1)
dbo.permissions.t.insert().execute(permission="release",
username="******",
options=dict(products=["a"],
actions=["modify"]),
data_version=1)
dbo.permissions.t.insert().execute(permission="rule",
username="******",
options=dict(products=["fake"],
actions=["create"]),
data_version=1)
dbo.permissions.t.insert().execute(permission="release_read_only",
username="******",
options=dict(actions=["set"],
products=["a", "b"]),
data_version=1)
dbo.permissions.t.insert().execute(permission="rule",
username="******",
options=dict(actions=["modify"],
products=["a", "b"]),
data_version=1)
dbo.permissions.t.insert().execute(permission="release",
username="******",
options=dict(actions=["modify"],
products=["a"]),
data_version=1)
dbo.permissions.t.insert().execute(permission="scheduled_change",
username="******",
options=dict(actions=["enact"]),
data_version=1)
dbo.permissions.t.insert().execute(permission="release_locale",
username="******",
options=dict(actions=["modify"],
products=["a"]),
data_version=1)
dbo.permissions.t.insert().execute(permission="admin",
username="******",
options=dict(products=["a"]),
data_version=1)
dbo.permissions.user_roles.t.insert().execute(username="******",
role="releng",
data_version=1)
dbo.permissions.user_roles.t.insert().execute(username="******",
role="qa",
data_version=1)
dbo.permissions.user_roles.t.insert().execute(username="******",
role="relman",
data_version=1)
dbo.permissions.user_roles.t.insert().execute(username="******",
role="releng",
data_version=1)
dbo.permissions.user_roles.t.insert().execute(username="******",
role="relman",
data_version=1)
dbo.productRequiredSignoffs.t.insert().execute(product="fake",
channel="a",
role="releng",
signoffs_required=1,
data_version=1)
dbo.productRequiredSignoffs.t.insert().execute(product="fake",
channel="e",
role="releng",
signoffs_required=1,
data_version=1)
dbo.productRequiredSignoffs.t.insert().execute(product="fake",
channel="j",
role="releng",
signoffs_required=1,
data_version=1)
dbo.productRequiredSignoffs.t.insert().execute(product="fake",
channel="k",
role="relman",
signoffs_required=1,
data_version=2)
dbo.productRequiredSignoffs.history.t.insert().execute(
change_id=1,
changed_by="bill",
timestamp=10,
product="fake",
channel="k",
role="relman")
dbo.productRequiredSignoffs.history.t.insert().execute(
change_id=2,
changed_by="bill",
timestamp=11,
product="fake",
channel="k",
role="relman",
signoffs_required=2,
data_version=1)
dbo.productRequiredSignoffs.history.t.insert().execute(
change_id=3,
changed_by="bill",
timestamp=25,
product="fake",
channel="k",
role="relman",
signoffs_required=1,
data_version=2)
dbo.permissionsRequiredSignoffs.t.insert().execute(product="fake",
role="releng",
signoffs_required=1,
data_version=1)
dbo.permissionsRequiredSignoffs.t.insert().execute(product="bar",
role="releng",
signoffs_required=1,
data_version=1)
dbo.permissionsRequiredSignoffs.t.insert().execute(product="blah",
role="releng",
signoffs_required=1,
data_version=1)
dbo.permissionsRequiredSignoffs.t.insert().execute(product="doop",
role="releng",
signoffs_required=1,
data_version=2)
dbo.permissionsRequiredSignoffs.t.insert().execute(product="superfake",
role="relman",
signoffs_required=1,
data_version=1)
dbo.permissionsRequiredSignoffs.history.t.insert().execute(
change_id=1,
changed_by="bill",
timestamp=10,
product="doop",
role="releng")
dbo.permissionsRequiredSignoffs.history.t.insert().execute(
change_id=2,
changed_by="bill",
timestamp=11,
product="doop",
role="releng",
signoffs_required=2,
data_version=1)
dbo.permissionsRequiredSignoffs.history.t.insert().execute(
change_id=3,
changed_by="bill",
timestamp=25,
product="doop",
role="releng",
signoffs_required=1,
data_version=2)
dbo.releases.t.insert().execute(name="a",
product="a",
data=createBlob(
dict(name="a",
hashFunction="sha512",
schema_version=1)),
data_version=1)
dbo.releases.t.insert().execute(name="ab",
product="a",
data=createBlob(
dict(name="ab",
hashFunction="sha512",
schema_version=1)),
data_version=1)
dbo.releases.history.t.insert().execute(change_id=1,
timestamp=5,
changed_by="bill",
name="ab")
dbo.releases.history.t.insert().execute(
change_id=2,
timestamp=6,
changed_by="bill",
name="ab",
product="a",
data=createBlob(
dict(name="ab", hashFunction="sha512", schema_version=1)),
data_version=1,
)
dbo.releases.t.insert().execute(name="b",
product="b",
data=createBlob(
dict(name="b",
hashFunction="sha512",
schema_version=1)),
data_version=1)
dbo.releases.history.t.insert().execute(change_id=5,
timestamp=15,
changed_by="bill",
name="b")
dbo.releases.history.t.insert().execute(
change_id=6,
timestamp=16,
changed_by="bill",
name="b",
product="b",
data=createBlob(
dict(name="b", hashFunction="sha512", schema_version=1)),
data_version=1,
)
dbo.releases.t.insert().execute(name="c",
product="c",
data=createBlob(
dict(name="c",
hashFunction="sha512",
schema_version=1)),
data_version=1)
dbo.releases.t.insert().execute(
name="d",
product="d",
data_version=1,
data=createBlob("""
{
"name": "d",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"d": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}
"""),
)
dbo.releases.history.t.insert().execute(change_id=3,
timestamp=9,
changed_by="bill",
name="d")
dbo.releases.history.t.insert().execute(
change_id=4,
timestamp=10,
changed_by="bill",
name="d",
product="d",
data_version=1,
data=createBlob("""
{
"name": "d",
"schema_version": 1,
"hashFunction": "sha512",
"platforms": {
"p": {
"locales": {
"d": {
"complete": {
"filesize": 1234,
"from": "*",
"hashValue": "abc"
}
}
}
}
}
}
"""),
)
dbo.rules.t.insert().execute(
rule_id=1,
priority=100,
version="3.5",
buildTarget="d",
backgroundRate=100,
mapping="c",
update_type="minor",
product="a",
channel="a",
data_version=1,
)
dbo.rules.t.insert().execute(
rule_id=2,
alias="frodo",
priority=100,
version="3.3",
buildTarget="d",
backgroundRate=100,
mapping="b",
update_type="minor",
product="a",
channel="a",
data_version=1,
)
dbo.rules.t.insert().execute(
rule_id=3,
product="a",
priority=100,
version="3.5",
buildTarget="a",
backgroundRate=100,
mapping="a",
update_type="minor",
channel="a",
data_version=1,
)
dbo.rules.t.insert().execute(rule_id=4,
product="fake",
priority=80,
buildTarget="d",
backgroundRate=100,
mapping="a",
update_type="minor",
channel="a",
data_version=1)
dbo.rules.t.insert().execute(rule_id=5,
priority=80,
buildTarget="d",
version="3.3",
backgroundRate=0,
mapping="c",
update_type="minor",
product="a",
channel="a",
data_version=1)
dbo.rules.t.insert().execute(rule_id=6,
product="fake",
priority=40,
backgroundRate=50,
mapping="a",
update_type="minor",
channel="e",
data_version=1)
dbo.rules.t.insert().execute(rule_id=7,
product="fake",
priority=30,
backgroundRate=85,
mapping="a",
update_type="minor",
channel="c",
data_version=1)
dbo.rules.t.insert().execute(rule_id=8,
product="fake2",
priority=25,
backgroundRate=100,
mapping="a",
update_type="minor",
channel="c",
mig64=True,
data_version=1)
dbo.rules.t.insert().execute(rule_id=9,
product="fake3",
priority=25,
backgroundRate=100,
mapping="a",
update_type="minor",
channel="c",
jaws=True,
data_version=1)
self.client = app.test_client()
def setup(self, insert_release, firefox_54_0_1_build1, firefox_56_0_build1,
superblob_e8f4a19, hotfix_bug_1548973_1_1_4, timecop_1_0):
app.config["DEBUG"] = True
self.public_client = app.test_client()
dbo.setDb("sqlite:///:memory:")
self.metadata.create_all(dbo.engine)
dbo.rules.t.insert().execute(rule_id=1,
priority=90,
backgroundRate=100,
mapping="Fennec.55.0a1",
update_type="minor",
product="Fennec",
data_version=1,
alias="moz-releng")
dbo.releases.t.insert().execute(
name="Fennec.55.0a1",
product="Fennec",
data_version=1,
data=createBlob("""
{
"name": "Fennec.55.0a1",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "2",
"locales": {
"l": {
"complete": {
"filesize": "3",
"from": "*",
"hashValue": "4",
"fileUrl": "http://a.com/z"
}
},
"xh": {
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "6",
"fileUrl": "http://a.com/x"
}
}
}
}
}
}
"""),
)
dbo.rules.t.insert().execute(rule_id=2,
priority=90,
backgroundRate=100,
mapping="Firefox.55.0a1",
update_type="minor",
product="Firefox",
instructionSet="SSE",
data_version=1)
dbo.releases.t.insert().execute(
name="Firefox.55.0a1",
product="Firefox",
data_version=1,
data=createBlob("""
{
"name": "Firefox.55.0a1",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "5",
"locales": {
"l": {
"buildID": "5",
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "5",
"fileUrl": "http://a.com/s"
}
}
}
}
}
}
"""),
)
dbo.rules.t.insert().execute(rule_id=3,
priority=90,
backgroundRate=0,
mapping="q",
update_type="minor",
product="q",
data_version=3)
dbo.rules.history.t.insert().execute(change_id=1,
changed_by="usr",
timestamp=10,
rule_id=3,
priority=90,
backgroundRate=0,
mapping="y",
update_type="minor",
product="y",
data_version=2)
dbo.rules.history.t.insert().execute(change_id=2,
changed_by="usr",
timestamp=10,
rule_id=3,
priority=90,
backgroundRate=0,
mapping="z",
update_type="minor",
product="z",
data_version=1)
dbo.releases.t.insert().execute(
name="q",
product="q",
data_version=2,
data=createBlob("""
{
"name": "q",
"schema_version": 1,
"appv": "1.0",
"extv": "1.0",
"hashFunction": "sha512",
"platforms": {
"p": {
"buildID": "6",
"locales": {
"l": {
"complete": {
"filesize": "5",
"from": "*",
"hashValue": "5",
"fileUrl": "http://a.com/q"
}
}
}
}
}
}
"""),
)
dbo.rules.t.insert().execute(rule_id=4,
priority=90,
backgroundRate=100,
mapping="Firefox.55.0a1",
update_type="minor",
product="Firefox",
mig64=True,
data_version=1)
insert_release(firefox_54_0_1_build1, "Firefox", history=False)
insert_release(firefox_56_0_build1, "Firefox", history=False)
insert_release(superblob_e8f4a19, "SystemAddons", history=False)
insert_release(hotfix_bug_1548973_1_1_4, "SystemAddons", history=False)
insert_release(timecop_1_0, "SystemAddons", history=False)
def _process_JSON_data(self, valuelist):
self.data = createBlob(valuelist[0])
self.data.isValid()
def createRelease(release, product, changed_by, transaction, releaseData):
blob = createBlob(json.dumps(releaseData))
dbo.releases.insert(changed_by=changed_by, transaction=transaction, name=release,
product=product, data=blob)
return dbo.releases.getReleases(name=release, transaction=transaction)[0]
