def introspect(self) -> Result[dict, dict]:
try:
result = self.schema.introspect()
except Exception as e:
return Result.Err({"errors": [str(e)]})
else:
return Result.Ok(result)
def test_ok_err(ok):
res = Result.Ok(1) if ok else Result.Err(1)
if ok:
assert res.ok() == Some(1)
assert res.err() == NONE
else:
assert res.ok() == NONE
assert res.err() == Some(1)
def execute(self, gql_request: GraphqlRequest,
context: Context) -> Result[dict, dict]:
result = self.schema.execute(gql_request.query,
variables=gql_request.variables,
context=context)
json = result.to_dict()
if result.errors:
return Result.Err(json)
else:
return Result.Ok(json)
def parse_graphql_request(
request: flask.Request) -> Result[GraphqlRequest, str]:
request_json = request.json
if not request_json:
return Result.Err("Not a valid JSON request")
query = request_json.get("query")
if not query:
return Result.Err("Could not find GraphQL query for request")
variables = request_json.get("variables")
return Result.Ok(GraphqlRequest(query, variables))
class TestExecuteGql:
def test_post_success(self):
expected_data = {"data": {"f": "s"}}
query = "foo"
request = MagicMock(Request)
request.method = "POST"
request.json = {"query": query}
gql_request = GraphqlRequest(query)
mock_gql_controller.execute = MagicMock(return_value=Result.Ok(expected_data))
result = app.execute_gql(request)
assert result.unwrap() == expected_data
mock_gql_controller.execute.assert_called_once_with(
gql_request, app.create_context(...)
)
def test_post_parse_fail(self):
request = MagicMock(Request)
request.method = "POST"
request.json = None
mock_gql_controller.execute = MagicMock()
result = app.execute_gql(request)
for err in result.unwrap_err()["errors"]:
assert isinstance(err, str)
mock_gql_controller.execute.assert_not_called()
@pytest.mark.parametrize(
"expected_result", [Result.Ok({"foo": "bar"}), Result.Err({"bar": "qux"})]
)
def test_get(self, expected_result):
request = MagicMock(Request)
request.method = "GET"
mock_gql_controller.introspect = MagicMock(return_value=expected_result)
result = app.execute_gql(request)
assert result == expected_result
mock_gql_controller.introspect.assert_called_once_with()
def test_post_success(self):
expected_data = {"data": {"f": "s"}}
query = "foo"
request = MagicMock(Request)
request.method = "POST"
request.json = {"query": query}
gql_request = GraphqlRequest(query)
mock_gql_controller.execute = MagicMock(return_value=Result.Ok(expected_data))
result = app.execute_gql(request)
assert result.unwrap() == expected_data
mock_gql_controller.execute.assert_called_once_with(
gql_request, app.create_context(...)
)
class TestExecuteGql:
@pytest.mark.parametrize("success", [True, False])
def test_post(self, success):
expected_data = {"data": {"f": "s"}}
query = "foo"
request = MagicMock(Request)
request.headers = {"Authorization": "Bearer TOKEN"}
request.method = "POST"
request.json = {"query": query}
gql_request = GraphqlRequest(query)
result = Ok(expected_data) if success else Err(expected_data)
mock_gql_controller.execute = MagicMock(return_value=result)
result = app.execute_gql(request)
if success:
assert result.unwrap() == expected_data
else:
assert result.unwrap_err() == HttpError(400, expected_data)
mock_gql_controller.execute.assert_called_once_with(
gql_request, app.create_secure_context(request).unwrap()
)
def test_post_parse_fail(self):
request = MagicMock(Request)
request.method = "POST"
request.json = None
mock_gql_controller.execute = MagicMock()
result = app.execute_gql(request)
assert result.unwrap_err().code == 400
for err in result.unwrap_err().to_dict()["errors"]:
assert isinstance(err, str)
mock_gql_controller.execute.assert_not_called()
def test_post_auth_fail(self):
request = MagicMock(Request)
request.method = "POST"
request.json = {"query": "bar"}
error = fake.pystr()
mock_gql_controller.execute = MagicMock()
_old_create_secure_context = app.create_secure_context
app.create_secure_context = MagicMock(return_value=Err(error))
result = app.execute_gql(request)
assert result.unwrap_err().code == 401
assert result.unwrap_err().to_dict() == {"errors": [error]}
mock_gql_controller.execute.assert_not_called()
app.create_secure_context = _old_create_secure_context
@pytest.mark.parametrize(
"expected_result", [Result.Ok({"foo": "bar"}), Result.Err({"bar": "qux"})]
)
def test_get(self, expected_result):
request = MagicMock(Request)
request.method = "GET"
mock_gql_controller.introspect = MagicMock(return_value=expected_result)
result = app.execute_gql(request)
if result.is_err:
assert result.unwrap_err() == HttpError(400, expected_result.unwrap_err())
else:
assert result.unwrap()["data"] == expected_result.unwrap()
mock_gql_controller.introspect.assert_called_once_with()
def test_bool(ok):
res = Result.Ok(1) if ok else Result.Err(1)
assert bool(res) == ok
assert res.is_ok == ok
assert res.is_err != ok
def test_factory_err(err):
res = Result.Err(err)
assert not res._is_ok
assert res._val == err
def test_factory_ok(val):
res = Result.Ok(val)
assert res._is_ok
assert res._val == val
def test_no_init(args):
with pytest.raises(TypeError):
Result(*args)