def test_search_variants_paging_token(self):
"""Tests that paging works as expected for the search variants endpoint."""
# Request a very large range of variants
request = self.factory.post(
"/data/ga4gh/variants/search", json.dumps(
{"end": 45158029,
"referenceName": "chr13",
"variantSetId": "brca-hg37",
"start": 20425158,
"pageSize": 5}), content_type="application/json")
response = views.search_variants(request)
self.assertEqual(
json.loads(response.content)["nextPageToken"],
"1", "A page token should be set")
start = 41245664
end = 42245664
request = self.factory.post(
"/data/ga4gh/variants/search", json.dumps(
{"end": end,
"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": start,
"pageSize": 5,
"pageToken": "3"}), content_type="application/json", )
response = json.loads(views.search_variants(request).content)
for variant in response["variants"]:
self.assertGreater(long(variant["end"]), start)
self.assertLess(long(variant["start"]), end,
"Should be in range"
" v.start {} r.end {}".format(variant['start'], end))
self.assertEqual(response["nextPageToken"], "4")
self.assertEquals(len(response["variants"]), 5)
def test_search_variants_requested_range_present(self):
"""Ensures variants returned via search have the expected range."""
start = 41246794
end = 41247374
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({
"end": end,
"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": start
}),
content_type="application/json")
response = views.search_variants(request)
jresp = json.loads(response.content)
self.assertGreater(len(jresp["variants"]), 0)
for variant in jresp["variants"]:
self.assertTrue(long(variant["end"]) > start)
self.assertTrue(
long(variant["start"]) < end, "Should be in range"
" v.start {} r.end {}".format(variant['start'], end))
self.assertTrue(variant["referenceName"] == "chr17")
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({
"end": end,
"referenceName": "17",
"variantSetId": "brca-hg37",
"start": start
}),
content_type="application/json")
response1 = views.search_variants(request)
self.assertEqual(response.content, response1.content,
"Both 17 and chr17 return the same results")
def test_search_variants_requested_range_present(self):
"""Ensures variants returned via search have the expected range."""
start = 41246794
end = 41247374
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({"end": end,
"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": start}),
content_type = "application/json")
response = views.search_variants(request)
jresp = json.loads(response.content)
self.assertGreater(len(jresp["variants"]), 0)
for variant in jresp["variants"]:
self.assertTrue(long(variant["end"]) > start)
self.assertTrue(long(variant["start"]) < end,
"Should be in range"
" v.start {} r.end {}".format(variant['start'], end))
self.assertTrue(
variant["referenceName"] == "chr17" or variant["referenceName"] == "17",
"Searched for chr17 and got {}".format(variant["referenceName"]))
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({"end": end,
"referenceName": "17",
"variantSetId": "brca-hg37",
"start": start}),
content_type = "application/json")
response1 = views.search_variants(request)
self.assertEqual(response.content, response1.content,
"Both 17 and chr17 return the same results")
def test_search_unsupported_region(self):
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({
"referenceName": "chr13",
"variantSetId": "brca-hg36",
"start": 10,
"end": 10000
}),
content_type="application/json")
response = views.search_variants(request)
json_response = json.loads(response.content)
"""Note that it is an empty response, no variants exist within
the provided search range"""
self.assertEqual(json_response['nextPageToken'], unicode(''))
self.assertEqual(json_response['variants'], list([]))
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({
"referenceName": "5",
"variantSetId": "brca-hg36",
"start": 10,
"end": 10000000000
}),
content_type="application/json")
response = views.search_variants(request)
json_response = json.loads(response.content)
"""Note that it is an empty response, no variants exist within
the provided search range"""
self.assertEqual(response.status_code, 200)
self.assertEqual(json_response['nextPageToken'], unicode(''))
self.assertEqual(json_response['variants'], list([]))
def test_get_variant_by_id(self):
"""Ensures the results found via search variants and get variant by ID are equal."""
search_request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start" : 4124692, "end" : 41247086,
"pageSize": 1}),
content_type="application/json"
)
search_response = views.search_variants(search_request)
json_search_response = json.loads(search_response.content)["variants"][0]
self.assertIsNotNone(json_search_response["variantSetId"])
self.assertIsNotNone(json_search_response["referenceName"])
self.assertIsNotNone(json_search_response["id"])
search_based_id = str(json_search_response['id'])
get_request = self.factory.get("/data/ga4gh/variants/"+search_based_id)
response = views.get_variant(get_request, search_based_id)
json_get_response = json.loads(response.content)
"""Note, because we made a get_request based on the search above,
we should be able to confirm that the individual variant request is exactly the same one"""
self.assertEqual(json_get_response["referenceName"], json_search_response["referenceName"])
self.assertEqual(json_get_response["start"], json_search_response["start"])
self.assertEqual(json_get_response["end"], json_search_response["end"])
def test_get_variant_by_id(self):
"""Ensures the results found via search variants and get variant by ID are equal."""
search_request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({
"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": 4124692,
"end": 41247086,
"pageSize": 1
}),
content_type="application/json")
search_response = views.search_variants(search_request)
json_search_response = json.loads(
search_response.content)["variants"][0]
self.assertIsNotNone(json_search_response["variantSetId"])
self.assertIsNotNone(json_search_response["referenceName"])
self.assertIsNotNone(json_search_response["id"])
search_based_id = str(json_search_response['id'])
get_request = self.factory.get("/data/ga4gh/variants/" +
search_based_id)
response = views.get_variant(get_request, search_based_id)
json_get_response = json.loads(response.content)
"""Note, because we made a get_request based on the search above,
we should be able to confirm that the individual variant request is exactly the same one"""
self.assertEqual(json_get_response["referenceName"],
json_search_response["referenceName"])
self.assertEqual(json_get_response["start"],
json_search_response["start"])
self.assertEqual(json_get_response["end"], json_search_response["end"])
def test_ordered_range_for_search_variant(self):
START = 41246925
END = 41247084
# Assure Start is less than End
self.assertGreater(END, START)
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": START, "end": END,
"pageSize": 9}),
content_type="application/json")
response = views.search_variants(request)
json_response = json.loads(response.content)["variants"]
previews_start = 0
for variant in json_response:
if previews_start == 0:
previews_start = variant['start']
self.assertGreaterEqual(variant["start"], START)
else:
"""Note that if in order ranged is returned
the previews start value should be less than the following
in the list"""
if variant['end'] == END:
break
self.assertLess(previews_start, variant['start'])
previews_start = variant['start']
def test_ordered_range_for_search_variant(self):
START = 41246925
END = 41247084
# Assure Start is less than End
self.assertGreater(END, START)
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({
"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": START,
"end": END,
"pageSize": 9
}),
content_type="application/json")
response = views.search_variants(request)
json_response = json.loads(response.content)["variants"]
previews_start = 0
for variant in json_response:
if previews_start == 0:
previews_start = variant['start']
self.assertGreaterEqual(variant["start"], START)
else:
"""Note that if in order ranged is returned
the previews start value should be less than the following
in the list"""
if variant['end'] == END:
break
self.assertLess(previews_start, variant['start'])
previews_start = variant['start']
def test_search_variants_paging_token(self):
"""Tests that paging works as expected for the search variants endpoint."""
# Request a very large range of variants
counter = 50
start = 31222950
end = 51222977
while counter > 5:
new_v = test_data.existing_variant()
# Genomic coordinates are irrelevant to this test, but the format is required regardless
new_v['Genomic_Coordinate_hg38'] = 'chr17:g.' + str(start-counter) + ':A>G'
new_v['Genomic_Coordinate_hg37'] = 'chr17:g.' + str(end-counter) + ':A>G'
new_v['Hg37_Start'] = end - counter
new_v['Hg37_End'] = end - counter
create_variant_and_materialized_view(new_v)
counter -= 1
request = self.factory.post(
"/data/ga4gh/variants/search", json.dumps(
{"end": end,
"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": start,
"pageSize": 5}), content_type="application/json")
response = views.search_variants(request)
self.assertEqual(
json.loads(response.content)["nextPageToken"],
"1", "A page token should be set")
request = self.factory.post(
"/data/ga4gh/variants/search", json.dumps(
{"end": end,
"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": start,
"pageSize": 5,
"pageToken": "3"}), content_type="application/json", )
response = json.loads(views.search_variants(request).content)
for variant in response["variants"]:
self.assertGreater(long(variant["end"]), start)
self.assertLess(long(variant["start"]), end,
"Should be in range"
" v.start {} r.end {}".format(variant['start'], end))
self.assertEqual(response["nextPageToken"], "4")
self.assertEquals(len(response["variants"]), 5)
def test_search_variants_alive(self):
"""Ensures that search variants responds successfully for a known search"""
request = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps(
{"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": 51425158,
"end": 515158029,
"pageSize": 5 }), content_type="application/json")
response = views.search_variants(request)
self.assertEqual(response.status_code, 200)
def test_search_variants_alive(self):
"""Ensures that search variants responds successfully for a known search"""
request = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps(
{"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": 51425158,
"end": 515158029,
"pageSize": 5 }), content_type="application/json")
response = views.search_variants(request)
self.assertEqual(response.status_code, 200)
def test_search_variants_paging_token(self):
"""Tests that paging works as expected for the search variants endpoint."""
# Request a very large range of variants
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({
"end": 45158029,
"referenceName": "chr13",
"variantSetId": "brca-hg37",
"start": 20425158,
"pageSize": 5
}),
content_type="application/json")
response = views.search_variants(request)
self.assertEqual(
json.loads(response.content)["nextPageToken"], "1",
"A page token should be set")
start = 41245664
end = 42245664
request = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps({
"end": end,
"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": start,
"pageSize": 5,
"pageToken": "3"
}),
content_type="application/json",
)
response = json.loads(views.search_variants(request).content)
for variant in response["variants"]:
self.assertGreater(long(variant["end"]), start)
self.assertLess(
long(variant["start"]), end, "Should be in range"
" v.start {} r.end {}".format(variant['start'], end))
self.assertEqual(response["nextPageToken"], "4")
self.assertEquals(len(response["variants"]), 5)
def test_search_unsupported_region(self):
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({"referenceName": "chr13",
"variantSetId": "brca-hg36",
"start": 10, "end": 10000}),
content_type="application/json")
response = views.search_variants(request)
json_response = json.loads(response.content)
"""Note that it is an empty response, no variants exist within
the provided search range"""
self.assertEqual(json_response['nextPageToken'], unicode(''))
self.assertEqual(json_response['variants'], list([]))
request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({"referenceName": "5",
"variantSetId": "brca-hg36",
"start": 10, "end": 10000000000}),
content_type="application/json")
response = views.search_variants(request)
json_response = json.loads(response.content)
"""Note that it is an empty response, no variants exist within
the provided search range"""
self.assertEqual(response.status_code, 200)
self.assertEqual(json_response['nextPageToken'], unicode(''))
self.assertEqual(json_response['variants'], list([]))
def test_search_variants_empty_page_request(self):
"""This would be the same response when a requested
range is not supported, that is, no variants are registered
within the requested range"""
request = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps({"variantSetId": "brca-hg37",
"referenceName": "chr17",
"start": 10000, "end": 41196822,
"pageSize": 10, "pageToken": "5"}),
content_type="application/json")
response = views.search_variants(request)
json_response = json.loads(response.content)
# Note that it is an empty response, therefore assertions are done to empty values
self.assertEqual(json_response["nextPageToken"], "")
self.assertEqual(json_response["variants"], list([]))
def test_search_variants_empty_page_request(self):
"""This would be the same response when a requested
range is not supported, that is, no variants are registered
within the requested range"""
request = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps({"variantSetId": "brca-hg37",
"referenceName": "chr17",
"start": 10000, "end": 41196822,
"pageSize": 10, "pageToken": "5"}),
content_type="application/json")
response = views.search_variants(request)
json_response = json.loads(response.content)
# Note that it is an empty response, therefore assertions are done to empty values
self.assertEqual(json_response["nextPageToken"], "")
self.assertEqual(json_response["variants"], list([]))
def test_search_variants_request_validation(self):
"""Ensures the search variants endpoint responds with expected failure modes"""
request = variant_service.SearchVariantsRequest()
req = self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertEqual(response.status_code, 400, "No variant set ID should 400")
self.assertJSONEqual(response.content,
views.ErrorMessages['variantSetId'],
"No variant set ID in the request should provide a useful error")
request.variant_set_id = "Something not null"
req = self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertEquals(response.status_code, 400)
self.assertJSONEqual(response.content,
views.ErrorMessages['referenceName'],
"A useful error is thrown when the reference name is not present")
request.reference_name = "chr17"
req= self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertJSONEqual(response.content,
views.ErrorMessages['start'],
"A useful error is thrown when no start is present")
request.start = 14589
req = self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertJSONEqual(response.content, views.ErrorMessages['end'],
"A useful error is provided when no end is present")
request.end = 143295
req = self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertEquals(response.status_code, 404, "A bad variant set ID should 404")
# Test for an end value less than the end value
test_request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({"referenceName": "chr17", "variantSetId": "brca-hg37", "start": 10000, "end": 1000}),
content_type="application/json")
response_x = views.search_variants(test_request)
self.assertEqual(response_x.status_code, 400)
self.assertJSONEqual(response_x.content, views.ErrorMessages['invalidPositions'])
def test_search_variants_request_validation(self):
"""Ensures the search variants endpoint responds with expected failure modes"""
request = variant_service.SearchVariantsRequest()
req = self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertEqual(response.status_code, 400, "No variant set ID should 400")
self.assertJSONEqual(response.content,
views.ErrorMessages['variantSetId'],
"No variant set ID in the request should provide a useful error")
request.variant_set_id = "Something not null"
req = self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertEquals(response.status_code, 400)
self.assertJSONEqual(response.content,
views.ErrorMessages['referenceName'],
"A useful error is thrown when the reference name is not present")
request.reference_name = "chr17"
req= self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertJSONEqual(response.content,
views.ErrorMessages['start'],
"A useful error is thrown when no start is present")
request.start = 14589
req = self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertJSONEqual(response.content, views.ErrorMessages['end'],
"A useful error is provided when no end is present")
request.end = 143295
req = self.factory.post("/data/ga4gh/variants/search",
json.dumps(json_format.MessageToDict(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertEquals(response.status_code, 404, "A bad variant set ID should 404")
# Test for an end value less than the end value
test_request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({"referenceName": "chr17", "variantSetId": "brca-hg37", "start": 10000, "end": 1000}),
content_type="application/json")
response_x = views.search_variants(test_request)
self.assertEqual(response_x.status_code, 400)
self.assertJSONEqual(response_x.content, views.ErrorMessages['invalidPositions'])
