feat: increase test cov

Author: Raezil

document_test.go

@@ -25,3 +25,59 @@ func TestDocumentTokenLiteral(t *testing.T) {
 		t.Errorf("expected empty string, got %q", got)
 	}
 }
+
+func TestOperationDefinitionTokenLiteral(t *testing.T) {
+	// When Name is provided, TokenLiteral should return it.
+	opWithName := &OperationDefinition{
+		Operation: "query",
+		Name:      "GetUser",
+	}
+	if got := opWithName.TokenLiteral(); got != "GetUser" {
+		t.Errorf("expected 'GetUser', got %q", got)
+	}
+
+	// When Name is empty, TokenLiteral should return Operation.
+	opWithoutName := &OperationDefinition{
+		Operation: "mutation",
+		Name:      "",
+	}
+	if got := opWithoutName.TokenLiteral(); got != "mutation" {
+		t.Errorf("expected 'mutation', got %q", got)
+	}
+}
+
+func TestVariableDefinitionTokenLiteral(t *testing.T) {
+	varDef := &VariableDefinition{
+		Variable: "$id",
+	}
+	if got := varDef.TokenLiteral(); got != "$id" {
+		t.Errorf("expected '$id', got %q", got)
+	}
+}
+
+func TestFieldTokenLiteral(t *testing.T) {
+	field := &Field{
+		Name: "username",
+	}
+	if got := field.TokenLiteral(); got != "username" {
+		t.Errorf("expected 'username', got %q", got)
+	}
+}
+
+func TestArgumentTokenLiteral(t *testing.T) {
+	arg := &Argument{
+		Name: "limit",
+	}
+	if got := arg.TokenLiteral(); got != "limit" {
+		t.Errorf("expected 'limit', got %q", got)
+	}
+}
+
+func TestTypeDefinitionTokenLiteral(t *testing.T) {
+	typeDef := &TypeDefinition{
+		Name: "Query",
+	}
+	if got := typeDef.TokenLiteral(); got != "Query" {
+		t.Errorf("expected 'Query', got %q", got)
+	}
+}

graphql_test.go

@@ -530,33 +530,6 @@ func TestGraphqlHandler_MissingQueryField(t *testing.T) {
 	}
 }
 
-func TestOperationDefinitionTokenLiteral(t *testing.T) {
-	// When a name is provided.
-	op := &OperationDefinition{Operation: "query", Name: "MyQuery"}
-	if op.TokenLiteral() != "MyQuery" {
-		t.Errorf("expected TokenLiteral to be 'MyQuery', got %q", op.TokenLiteral())
-	}
-	// When no name is provided.
-	op = &OperationDefinition{Operation: "query", Name: ""}
-	if op.TokenLiteral() != "query" {
-		t.Errorf("expected TokenLiteral to be 'query', got %q", op.TokenLiteral())
-	}
-}
-
-func TestFieldTokenLiteral(t *testing.T) {
-	field := &Field{Name: "testField"}
-	if field.TokenLiteral() != "testField" {
-		t.Errorf("expected TokenLiteral to be 'testField', got %q", field.TokenLiteral())
-	}
-}
-
-func TestArgumentTokenLiteral(t *testing.T) {
-	arg := &Argument{Name: "arg1"}
-	if arg.TokenLiteral() != "arg1" {
-		t.Errorf("expected TokenLiteral to be 'arg1', got %q", arg.TokenLiteral())
-	}
-}
-
 func TestValueTokenLiteral(t *testing.T) {
 	val := &Value{Literal: "value"}
 	if val.TokenLiteral() != "value" {
@@ -745,15 +718,6 @@ func TestParseValue_Illegal(t *testing.T) {
 	}
 }
 
-// Test resolveField when no resolver is found for a top-level field.
-func TestResolveField_NoResolver(t *testing.T) {
-	field := &Field{Name: "nonexistent"}
-	_, err := resolveField(nil, field, nil)
-	if err == nil {
-		t.Error("expected error when no resolver is found for field 'nonexistent'")
-	}
-}
-
 // Test executeSelectionSet to skip non-Field selections.
 type dummySel struct{}
 

handler_test.go

@@ -3,20 +3,51 @@ package vibeGraphql
 import (
 	"bytes"
 	"encoding/json"
+	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 )
 
-func TestGraphqlHandler(t *testing.T) {
-	// Register a simple query resolver for testing.
-	RegisterQueryResolver("hello", func(source interface{}, args map[string]interface{}) (interface{}, error) {
-		return "world", nil
-	})
+func TestBuildValue_Object(t *testing.T) {
+	objValue := &Value{
+		Kind: "Object",
+		ObjectFields: map[string]*Value{
+			"key": {Kind: "String", Literal: "value"},
+			"num": {Kind: "Int", Literal: "42"},
+		},
+	}
+	result := buildValue(objValue, nil)
+	m, ok := result.(map[string]interface{})
+	if !ok {
+		t.Fatalf("expected map[string]interface{}, got %T", result)
+	}
+	if m["key"] != "value" {
+		t.Errorf("expected key 'value', got %v", m["key"])
+	}
+	// buildValue for Int converts to int.
+	if m["num"] != 42 {
+		t.Errorf("expected num 42, got %v", m["num"])
+	}
+}
+
+func TestGraphqlHandler_InvalidJSON(t *testing.T) {
+	req := httptest.NewRequest("POST", "/graphql", bytes.NewBuffer([]byte("invalid json")))
+	w := httptest.NewRecorder()
+
+	GraphqlHandler(w, req)
+	resp := w.Result()
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Errorf("expected status 400 for invalid JSON, got %d", resp.StatusCode)
+	}
+}
 
-	// Prepare a test GraphQL query.
+func TestGraphqlHandler_NoQuery(t *testing.T) {
+	// Send a JSON payload without the "query" field.
 	payload := map[string]interface{}{
-		"query": "{ hello }",
+		"notQuery": "test",
 	}
 	body, err := json.Marshal(payload)
 	if err != nil {
@@ -30,20 +61,140 @@ func TestGraphqlHandler(t *testing.T) {
 	resp := w.Result()
 	defer resp.Body.Close()
 
-	if resp.StatusCode != http.StatusOK {
-		t.Errorf("expected status 200, got %d", resp.StatusCode)
+	// When query is missing, the parser will likely create an empty document and return an error.
+	if resp.StatusCode != http.StatusInternalServerError {
+		t.Errorf("expected status 500 for missing query, got %d", resp.StatusCode)
 	}
+}
 
-	var result map[string]interface{}
-	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		t.Fatalf("error decoding response: %v", err)
+func TestGraphqlUploadHandler_MissingOperations(t *testing.T) {
+	// Simulate a multipart request missing the "operations" field.
+	var buf bytes.Buffer
+	writer := multipart.NewWriter(&buf)
+	// Create a dummy file field.
+	part, err := writer.CreateFormFile("file1", "dummy.txt")
+	if err != nil {
+		t.Fatalf("failed to create form file: %v", err)
+	}
+	part.Write([]byte("dummy content"))
+	writer.Close()
+
+	req := httptest.NewRequest("POST", "/graphql/upload", &buf)
+	req.Header.Set("Content-Type", "multipart/form-data; boundary="+writer.Boundary())
+
+	w := httptest.NewRecorder()
+	GraphqlUploadHandler(w, req)
+	resp := w.Result()
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Errorf("expected status 400 for missing operations field, got %d", resp.StatusCode)
+	}
+}
+
+func TestGraphqlUploadHandler_InvalidMap(t *testing.T) {
+	// Simulate a multipart request with invalid JSON in the "map" field.
+	var buf bytes.Buffer
+	writer := multipart.NewWriter(&buf)
+	// Write a valid operations field.
+	writer.WriteField("operations", `{"query": "{ hello }", "variables": {}}`)
+	// Write an invalid map field.
+	writer.WriteField("map", "not a valid json")
+	writer.Close()
+
+	req := httptest.NewRequest("POST", "/graphql/upload", &buf)
+	req.Header.Set("Content-Type", "multipart/form-data; boundary="+writer.Boundary())
+
+	w := httptest.NewRecorder()
+	GraphqlUploadHandler(w, req)
+	resp := w.Result()
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Errorf("expected status 400 for invalid map JSON, got %d", resp.StatusCode)
+	}
+}
+
+func TestSetNestedValueAndArrayValue(t *testing.T) {
+	var vars = make(map[string]interface{})
+	// Test setting a nested value.
+	setNestedValue(vars, "user.name", "Alice")
+	if vars["user"] == nil {
+		t.Fatal("expected nested map for user")
+	}
+	userMap, ok := vars["user"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("expected map for user, got %T", vars["user"])
+	}
+	if userMap["name"] != "Alice" {
+		t.Errorf("expected user.name to be 'Alice', got %v", userMap["name"])
 	}
 
+	// Test setting an array value.
+	setNestedArrayValue(vars, "files.0", "file1.txt")
+	arr, ok := vars["files"].([]interface{})
+	if !ok {
+		t.Fatalf("expected files to be an array, got %T", vars["files"])
+	}
+	if arr[0] != "file1.txt" {
+		t.Errorf("expected files[0] to be 'file1.txt', got %v", arr[0])
+	}
+}
+
+func TestExecuteDocument_NoDefinitions(t *testing.T) {
+	// Create a Document with no definitions.
+	doc := &Document{}
+	_, err := executeDocument(doc, nil)
+	if err == nil {
+		t.Error("expected error for document with no definitions, got nil")
+	}
+}
+
+func TestResolveField_NoResolver(t *testing.T) {
+	// Ensure that resolveField returns an error when no resolver is registered.
+	field := &Field{Name: "nonexistent"}
+	_, err := resolveField(nil, field, nil)
+	if err == nil {
+		t.Error("expected error for unresolved field, got nil")
+	}
+}
+
+func dummyHelloResolver(source interface{}, args map[string]interface{}) (interface{}, error) {
+	return "world", nil
+}
+
+func TestGraphqlHandler(t *testing.T) {
+	// Register the dummy resolver for the "hello" field.
+	QueryResolvers["hello"] = dummyHelloResolver
+
+	// Create a GraphQL query that requests the "hello" field.
+	reqBody, err := json.Marshal(map[string]interface{}{
+		"query": "query { hello }",
+	})
+	if err != nil {
+		t.Fatalf("failed to marshal request body: %v", err)
+	}
+	req := httptest.NewRequest("POST", "/graphql", bytes.NewBuffer(reqBody))
+	req.Header.Set("Content-Type", "application/json")
+
+	// Create a ResponseRecorder to capture the response.
+	rr := httptest.NewRecorder()
+	GraphqlHandler(rr, req)
+
+	res := rr.Result()
+	if res.StatusCode != http.StatusOK {
+		t.Errorf("expected status OK, got %v", res.StatusCode)
+	}
+
+	var result map[string]interface{}
+	if err := json.NewDecoder(res.Body).Decode(&result); err != nil {
+		t.Fatalf("failed to decode response body: %v", err)
+	}
 	data, ok := result["data"].(map[string]interface{})
 	if !ok {
-		t.Fatalf("expected data to be a map, got %v", result["data"])
+		t.Fatalf("expected response to contain 'data' field")
 	}
 	if data["hello"] != "world" {
-		t.Errorf("expected hello: world, got %v", data["hello"])
+		t.Errorf("expected field 'hello' to be 'world', got %v", data["hello"])
 	}
 }