feat: increase cov

Author: Raezil

handler_test.go

@@ -2,199 +2,181 @@ package vibeGraphql
 
 import (
 	"bytes"
-	"encoding/json"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 )
 
-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)
+func TestResolveArgument_Variable_Found(t *testing.T) {
+	vars := map[string]interface{}{
+		"var1": "variableValue",
 	}
-	if m["key"] != "value" {
-		t.Errorf("expected key 'value', got %v", m["key"])
+	arg := &Argument{Value: &Value{Kind: "Variable", Literal: "var1"}}
+	result, err := resolveArgument(arg, vars)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
 	}
-	// buildValue for Int converts to int.
-	if m["num"] != 42 {
-		t.Errorf("expected num 42, got %v", m["num"])
+	if result != "variableValue" {
+		t.Errorf("expected 'variableValue', got %v", result)
 	}
 }
 
-func TestGraphqlHandler_InvalidJSON(t *testing.T) {
-	req := httptest.NewRequest("POST", "/graphql", bytes.NewBuffer([]byte("invalid json")))
-	w := httptest.NewRecorder()
+func TestResolveArgument_Variable_NotFound(t *testing.T) {
+	arg := &Argument{Value: &Value{Kind: "Variable", Literal: "missingVar"}}
+	_, err := resolveArgument(arg, nil)
+	if err == nil {
+		t.Error("expected an error for missing variable, got nil")
+	}
+}
 
-	GraphqlHandler(w, req)
-	resp := w.Result()
-	defer resp.Body.Close()
+// ---------- Additional test for reflectResolve ----------
 
-	if resp.StatusCode != http.StatusBadRequest {
-		t.Errorf("expected status 400 for invalid JSON, got %d", resp.StatusCode)
-	}
+// DummyStruct is used to test reflective field resolution.
+type DummyStruct struct {
+	FieldA string `json:"fieldA"`
+	FieldB int
 }
 
-func TestGraphqlHandler_NoQuery(t *testing.T) {
-	// Send a JSON payload without the "query" field.
-	payload := map[string]interface{}{
-		"notQuery": "test",
-	}
-	body, err := json.Marshal(payload)
+func TestReflectResolve(t *testing.T) {
+	dummy := DummyStruct{FieldA: "valueA", FieldB: 99}
+	// Test by using the JSON tag.
+	field := &Field{Name: "fieldA"}
+	res, err := reflectResolve(dummy, field)
 	if err != nil {
-		t.Fatalf("failed to marshal payload: %v", err)
+		t.Fatalf("unexpected error: %v", err)
 	}
-
-	req := httptest.NewRequest("POST", "/graphql", bytes.NewBuffer(body))
-	w := httptest.NewRecorder()
-
-	GraphqlHandler(w, req)
-	resp := w.Result()
-	defer resp.Body.Close()
-
-	// 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)
+	if res != "valueA" {
+		t.Errorf("expected 'valueA', got %v", res)
 	}
-}
 
-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")
+	// Test by matching struct field name directly (case-insensitive).
+	field = &Field{Name: "FIELDB"}
+	res, err = reflectResolve(dummy, field)
 	if err != nil {
-		t.Fatalf("failed to create form file: %v", err)
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if res != 99 {
+		t.Errorf("expected 99, got %v", res)
 	}
-	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)
+	// Test with a non-existent field.
+	field = &Field{Name: "nonexistent"}
+	_, err = reflectResolve(dummy, field)
+	if err == nil {
+		t.Error("expected error for nonexistent field, got nil")
 	}
 }
 
-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()
+// ---------- Additional test for executeSelectionSet with nested selections ----------
 
-	req := httptest.NewRequest("POST", "/graphql/upload", &buf)
-	req.Header.Set("Content-Type", "multipart/form-data; boundary="+writer.Boundary())
+// DummyUser is used to simulate nested field resolution.
+type DummyUser struct {
+	Name string `json:"name"`
+	Age  int    `json:"age"`
+}
+
+func TestExecuteSelectionSet_Nested(t *testing.T) {
+	// Create a dummy user.
+	user := DummyUser{Name: "Alice", Age: 30}
 
-	w := httptest.NewRecorder()
-	GraphqlUploadHandler(w, req)
-	resp := w.Result()
-	defer resp.Body.Close()
+	// Manually create a selection set requesting "name" and "age".
+	selectionSet := &SelectionSet{
+		Selections: []Selection{
+			&Field{Name: "name"},
+			&Field{Name: "age"},
+		},
+	}
 
-	if resp.StatusCode != http.StatusBadRequest {
-		t.Errorf("expected status 400 for invalid map JSON, got %d", resp.StatusCode)
+	// Call executeSelectionSet with the dummy user as source.
+	result, err := executeSelectionSet(user, selectionSet, nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
 	}
-}
 
-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")
+	// Verify that the resulting map contains the expected values.
+	if result["name"] != "Alice" {
+		t.Errorf("expected name 'Alice', got %v", result["name"])
 	}
-	userMap, ok := vars["user"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("expected map for user, got %T", vars["user"])
+	if result["age"] != 30 {
+		t.Errorf("expected age 30, got %v", result["age"])
 	}
-	if userMap["name"] != "Alice" {
-		t.Errorf("expected user.name to be 'Alice', got %v", userMap["name"])
+}
+
+// ---------- Additional test for buildArgs ----------
+
+func TestBuildArgs(t *testing.T) {
+	// Create a field with arguments.
+	field := &Field{
+		Name: "dummy",
+		Arguments: []Argument{
+			{Name: "arg1", Value: &Value{Kind: "String", Literal: "hello"}},
+			{Name: "arg2", Value: &Value{Kind: "Int", Literal: "42"}},
+		},
 	}
 
-	// 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"])
+	args := buildArgs(field, nil)
+	if args["arg1"] != "hello" {
+		t.Errorf("expected arg1 to be 'hello', got %v", args["arg1"])
 	}
-	if arr[0] != "file1.txt" {
-		t.Errorf("expected files[0] to be 'file1.txt', got %v", arr[0])
+	if args["arg2"] != 42 {
+		t.Errorf("expected arg2 to be 42, got %v", args["arg2"])
 	}
 }
 
-func TestExecuteDocument_NoDefinitions(t *testing.T) {
-	// Create a Document with no definitions.
-	doc := &Document{}
+// ---------- Additional test for executeDocument error handling ----------
+
+func TestExecuteDocument_UnsupportedDefinition(t *testing.T) {
+	// Create a Document with an unsupported definition type.
+	doc := &Document{
+		Definitions: []Definition{
+			// Using a dummy implementation of Definition.
+			struct{ Node }{},
+		},
+	}
 	_, err := executeDocument(doc, nil)
 	if err == nil {
-		t.Error("expected error for document with no definitions, got nil")
+		t.Error("expected error for unsupported definition type, 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")
-	}
-}
+// ---------- Additional multipart upload tests can be added if needed ----------
 
-func dummyHelloResolver(source interface{}, args map[string]interface{}) (interface{}, error) {
-	return "world", nil
-}
+// For example, you might simulate a successful file upload with valid operations and map fields.
+// (This would likely require a temporary file or buffer with the correct multipart data.)
+// Here’s an example placeholder test that you can expand upon:
 
-func TestGraphqlHandler(t *testing.T) {
-	// Register the dummy resolver for the "hello" field.
-	QueryResolvers["hello"] = dummyHelloResolver
+func TestGraphqlUploadHandler_Success(t *testing.T) {
+	// Register a dummy resolver for "hello"
+	QueryResolvers["hello"] = func(source interface{}, args map[string]interface{}) (interface{}, error) {
+		return "world", nil
+	}
 
-	// Create a GraphQL query that requests the "hello" field.
-	reqBody, err := json.Marshal(map[string]interface{}{
-		"query": "query { hello }",
-	})
+	var buf bytes.Buffer
+	writer := multipart.NewWriter(&buf)
+	// Write valid operations field.
+	writer.WriteField("operations", `{"query": "{ hello }", "variables": {}}`)
+	// Write a valid map field.
+	writer.WriteField("map", `{"file1": ["variables.file"]}`)
+	// Create a dummy file.
+	part, err := writer.CreateFormFile("file1", "dummy.txt")
 	if err != nil {
-		t.Fatalf("failed to marshal request body: %v", err)
+		t.Fatalf("failed to create form file: %v", err)
 	}
-	req := httptest.NewRequest("POST", "/graphql", bytes.NewBuffer(reqBody))
-	req.Header.Set("Content-Type", "application/json")
+	part.Write([]byte("dummy content"))
+	writer.Close()
 
-	// Create a ResponseRecorder to capture the response.
-	rr := httptest.NewRecorder()
-	GraphqlHandler(rr, req)
+	// Use the proper upload endpoint.
+	req := httptest.NewRequest("POST", "/graphql/upload", &buf)
+	req.Header.Set("Content-Type", "multipart/form-data; boundary="+writer.Boundary())
 
+	rr := httptest.NewRecorder()
+	GraphqlUploadHandler(rr, req)
 	res := rr.Result()
-	if res.StatusCode != http.StatusOK {
-		t.Errorf("expected status OK, got %v", res.StatusCode)
-	}
+	defer res.Body.Close()
 
-	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 response to contain 'data' field")
-	}
-	if data["hello"] != "world" {
-		t.Errorf("expected field 'hello' to be 'world', got %v", data["hello"])
+	// Expect 200 OK since the query resolves correctly.
+	if res.StatusCode != http.StatusOK {
+		t.Errorf("expected status 200, got %d", res.StatusCode)
 	}
 }