func TestHandler_BasicQuery(t *testing.T) {
expected := &graphql.Result{
Data: map[string]interface{}{
"rebels": map[string]interface{}{
"id": "RmFjdGlvbjox",
"name": "Alliance to Restore the Republic",
},
},
}
queryString := `query=query RebelsShipsQuery { rebels { id, name } }`
req, _ := http.NewRequest("GET", fmt.Sprintf("/graphql?%v", queryString), nil)
h := handler.New(&handler.Config{
Schema: &starwars.Schema,
Pretty: true,
})
result, resp := executeTest(t, h, req)
if resp.Code != http.StatusOK {
t.Fatalf("unexpected server response %v", resp.Code)
}
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func main() {
log = log15.New()
log.Info("starting server...")
envconfig.Process("", &settings)
schema, err := graphql.NewSchema(makeSchema())
if err != nil {
log.Info("error creating schema", "err", err)
return
}
h := handler.New(&handler.Config{
Schema: &schema,
Pretty: false,
})
mux := http.NewServeMux()
mux.Handle("/graphql", h)
mux.Handle("/", http.FileServer(http.Dir("dist")))
log.Info("Listening at " + settings.Port + "...")
graceful.Run(":"+settings.Port, 1*time.Second, mux)
log.Info("Exiting...")
}
func init() {
apis, err := NewAPIs()
if err != nil {
panic(err)
}
h := handler.New(&handler.Config{
Schema: apis.Schema,
Pretty: true,
})
http.HandleFunc("/graphql", func(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
// Tracing.
span := Tracer.SpanFromRequest(r)
defer func() {
err := span.FinishWait()
if err != nil {
log.Errorf(ctx, "Failed to trace request: %s", err)
}
}()
ctx = trace.NewContext(ctx, span)
// Authentication.
auth := r.Header.Get("Authorization")
if auth != "" {
idToken, err := getIDToken(auth)
if err != nil {
// TODO#Errors
log.Errorf(ctx, "%s", err)
w.WriteHeader(http.StatusUnauthorized)
return
}
gu, err := GetGoogleUser(ctx, idToken)
if err != nil {
// TODO#Errors
log.Errorf(ctx, "%s", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
ctx = NewGoogleUserContext(ctx, gu)
}
// Caching.
ctx = NewCacheContext(ctx)
h.ContextHandler(ctx, w, r)
})
http.Handle("/static/", http.FileServer(http.Dir(".")))
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, "./static/index.html")
})
}
func main() {
// simplest relay-compliant graphql server HTTP handler
// using Starwars schema from `graphql-relay-go` examples
h := handler.New(&handler.Config{
Schema: &starwars.Schema,
Pretty: true,
})
// static file server to serve Graphiql in-browser editor
fs := http.FileServer(http.Dir("static"))
http.Handle("/graphql", h)
http.Handle("/", fs)
http.ListenAndServe(":8080", nil)
}
func TestHandler_Params_NilParams(t *testing.T) {
defer func() {
if r := recover(); r != nil {
if str, ok := r.(string); ok {
if str != "undefined GraphQL schema" {
t.Fatalf("unexpected error, got %v", r)
}
// test passed
return
}
t.Fatalf("unexpected error, got %v", r)
}
t.Fatalf("expected to panic, did not panic")
}()
_ = handler.New(nil)
}
func main() {
// simplest relay-compliant graphql server HTTP handler
h := handler.New(&handler.Config{
Schema: &data.Schema,
Pretty: true,
})
// create graphql endpoint
http.Handle("/graphql", h)
// serve!
port := ":8080"
log.Printf(`GraphQL server starting up on http://localhost%v`, port)
err := http.ListenAndServe(port, nil)
if err != nil {
log.Fatalf("ListenAndServe failed, %v", err)
}
}
func TestContextPropagated(t *testing.T) {
myNameQuery := graphql.NewObject(graphql.ObjectConfig{
Name: "Query",
Fields: graphql.Fields{
"name": &graphql.Field{
Name: "name",
Type: graphql.String,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
return p.Context.Value("name"), nil
},
},
},
})
myNameSchema, err := graphql.NewSchema(graphql.SchemaConfig{myNameQuery, nil})
if err != nil {
t.Fatal(err)
}
expected := &graphql.Result{
Data: map[string]interface{}{
"name": "context-data",
},
}
queryString := `query={name}`
req, _ := http.NewRequest("GET", fmt.Sprintf("/graphql?%v", queryString), nil)
h := handler.New(&handler.Config{
Schema: &myNameSchema,
Pretty: true,
})
ctx := context.WithValue(context.Background(), "name", "context-data")
resp := httptest.NewRecorder()
h.ContextHandler(ctx, resp, req)
result := decodeResponse(t, resp)
if resp.Code != http.StatusOK {
t.Fatalf("unexpected server response %v", resp.Code)
}
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
