Go gin nested JSON request body POST, error unexpected end of JSON input

Question

I am new to GO and was trying to create a simple POST API with gin and gorm.

The request data is nested JSON like below:

{
  "fall_orders_request": [
    {
      "fruit": "Watermelon",
      "vegetable": "Carrot"
    }
  ],
  "spring_orders_request": [
    {
      "fruit": "Watermelon",
      "vegetable": "Carrot",
      "cupcake": "minions"
    }
  ],
  "custome_rates": [
    {
      "fruit": "Watermelon",
      "greentea": "Japanese",
      "cupcake": "pokemon"
    }
  ]
}

After receiving the request i.e orders the backend will save it to corresponding Databases for each session.

This is my code for the orders.go:

package order

import (
    "net/http"

    "github.com/gin-gonic/gin"

    "gorm.io/gorm"
)

type FallOrders struct {
    ID        uint   `gorm:"primarykey"`
    Fruit     string `json:"fruit"`
    Vegetable string `json:"vegetable"`
}

type SpringOrders struct {
    ID        uint   `gorm:"primarykey"`
    Fruit     string `json:"fruit"`
    Vegetable string `json:"vegetable"`
    Cupcake   string `json:"cupcake"`
}

type WinterOrders struct {
    ID       uint   `gorm:"primarykey"`
    Fruit    string `json:"fruit"`
    Greentea string `json:"greentea"`
    Cupcake  string `json:"cupcake"`
}

type allOrders struct {
    FallOrders   []FallOrders   `json:"fall_orders"`
    SpringOrders []SpringOrders `json:"spring_orders"`
    WinterOrders []WinterOrders `json:"winter_orders"`
}

type FallOrdersRequest struct {
    Fruit     string `json:"fruit"`
    Vegetable string `json:"vegetable"`
}

type SpringOrdersRequest struct {
    Fruit     string `json:"fruit"`
    Vegetable string `json:"vegetable"`
    Cupcake   string `json:"cupcake"`
}

type WinterOrdersRequest struct {
    Fruit    string `json:"fruit"`
    Greentea string `json:"greentea"`
    Cupcake  string `json:"cupcake"`
}

type AllOrdersRequest struct {
    FallOrdersRequest   []FallOrdersRequest   `json:"fall_orders_request"`
    SpringOrdersRequest []SpringOrdersRequest `json:"spring_orders_request"`
    WinterOrdersRequest []WinterOrdersRequest `json:"winter_orders_request"`
}

type AllOrdersManager struct {
    DB *gorm.DB
}

type FallOrdersManager struct {
    DB *gorm.DB
}

type SpringOrdersManager struct {
    DB *gorm.DB
}

type WinterOrdersManager struct {
    DB *gorm.DB
}

func CreateModularRates() gin.HandlerFunc {
    return func(c *gin.Context) {
        var aor AllOrdersRequest
        var form FallOrdersManager
        var sorm SpringOrdersManager
        var worm WinterOrdersManager

        if err := c.BindJSON(&aor); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        for _, fall := range aor.FallOrdersRequest {

            fallOrders := FallOrders{
                Fruit:     fall.Fruit,
                Vegetable: fall.Vegetable,
            }
            c.JSON(http.StatusCreated, fallOrders)
            res := form.DB.Create(&fallOrders)
            if res.Error != nil {
                return
            }
        }

        for _, spring := range aor.SpringOrdersRequest {

            springOrders := SpringOrders{
                Fruit:     spring.Fruit,
                Vegetable: spring.Vegetable,
                Cupcake:   spring.Cupcake,
            }
            c.JSON(http.StatusCreated, springOrders)
            res := sorm.DB.Create(&springOrders)
            if res.Error != nil {
                return
            }
        }

        for _, winter := range aor.WinterOrdersRequest {

            winterOrders := WinterOrders{
                Fruit:    winter.Fruit,
                Greentea: winter.Greentea,
                Cupcake:  winter.Cupcake,
            }
            c.JSON(http.StatusCreated, winterOrders)
            res := worm.DB.Create(&winterOrders)
            if res.Error != nil {
                return
            }
        }

    }
}

And this is the automated test orders_test.go

package order

import (
    "bytes"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/gin-gonic/gin"
    "github.com/stretchr/testify/assert"
)

func TestOrderData() order.AllOrdersRequest {
    fall_orders_request := []order.FallOrdersRequest{}
    spring_orders_request := []order.SpringOrdersRequest{}
    winter_orders_request := []order.WinterOrdersRequest{}
    fall_orders_request = append(fall_orders_request, order.FallOrdersRequest{
        Fruit:     "Watermelon",
        Vegetable: "Carrot",
    })
    spring_orders_request = append(spring_orders_request, order.spring_orders_request{
        Fruit:     "Watermelon",
        Vegetable: "Carrot",
        Cupcake:   "minions",
    })
    winter_orders_request = append(winter_orders_request, order.winter_orders_request{
        Fruit:    "Watermelon",
        Greentea: "Japanese",
        Cupcake:  "pokemon",
    })

    return order.AllOrdersRequest{
        fall_orders_request:   fall_orders_request,
        spring_orders_request: spring_orders_request,
        winter_orders_request: winter_orders_request,
    }
}

func TestOrderCreation(t *testing.T) {
    params := TestOrderData()

    jsonPayload, _ := json.Marshal(params)
    w := httptest.NewRecorder()
    req, _ := http.NewRequest(
        "POST",
        "/orders",
        bytes.NewReader(jsonPayload),
    )
    var c *gin.Context
    assert.Equal(t, 201, w.Code)
    err2 := c.ShouldBindJSON(&req)
    if err2 == nil {
        return
    }

}

After running the test I get the following error:

Error: unexpected end of JSON input
{"message":"Error #01: EOF
"}

Logging the request shows the request body is JSON as expected but not sure why I am getting this error.

Go gin nested JSON request body POST, error unexpected end of JSON input

Answers (1)

Related Questions