How to fake httprequest in golang to write unittest for an api

func scanAndPushMsg(w http.ResponseWriter, r *http.Request) {
   ctx := r.Context()
   log := ctx.Value("RequestLogger").(*logger.Entry)

   if r.Body != nil {
      defer r.Body.Close()
   }

   roles := r.FormValue(RolesKey)
   actions := r.FormValue(ActionsKey)

   awardTypes := r.FormValue(AwardTypesKey)
   campaignIds := r.FormValue(CampaignIdsKey)

   log.Infof("scanAndPushMsg input: roles --%v--, actions --%v-- , awards  --%v-- ,campaignid --%v--", roles, actions, awardTypes, campaignIds)

   var reqBody jarvis.FilterCfgBody   reqBody.Roles = strings.TrimSpace(roles)
   reqBody.Actions = strings.TrimSpace(actions)
   reqBody.CampaignIDs = strings.TrimSpace(campaignIds)
   reqBody.AwardTypes = strings.TrimSpace(awardTypes)

   log.Infof("FilterCfgBody : %+v", reqBody)

   resp, err := scanAndPushSrv.ScanAndPush(reqBody, ctx)
   if err != nil {
      httputils.RespondError(w, err)
      return   }
   respondWithJSON(w, http.StatusOK, resp)
}

func Test_scanAndPushMsg(t *testing.T) {

   entry := log.WithContext(context.TODO())
   ctx := context.WithValue(context.Background(), "RequestLogger", entry)
   mockScanAndPush := new(mocks.ScanAndPush)
   reqBodySucces := jarvis.FilterCfgBody{
      Roles:       "Customer",
      AwardTypes:  "Redeemable",
      Actions:     "Credit",
      CampaignIDs: "12",
   }
   reqBodyFail := jarvis.FilterCfgBody{
      Roles:       "XXX",
      AwardTypes:  "Redeemable",
      Actions:     "Credit",
      CampaignIDs: "12",
   }

   resp := jarvis.ScanAndPushResp{
      Success:          nil,
      Failure:          nil,
      Total:            0,
      LastTime:         time.Time{},
      NewestRecordTime: time.Time{},
   }
   mockScanAndPush.On("ScanAndPush", reqBodySucces, ctx).Return(&resp, nil).Once()
   mockScanAndPush.On("ScanAndPush", reqBodyFail, ctx).Return(nil, errors.New("Error")).Once()
   Init(Cfg{
      ScanAndPushSrv: mockScanAndPush,
   })

   reqSucces, err := http.NewRequest("GET", "/scanAndPushInbox", nil)
   q := reqSucces.URL.Query()
   q.Add(ActionsKey, reqBodySucces.Actions)
   q.Add(RolesKey, reqBodySucces.Roles)
   q.Add(AwardTypesKey, reqBodySucces.AwardTypes)
   q.Add(CampaignIdsKey, reqBodySucces.CampaignIDs)
   reqSucces.URL.RawQuery = q.Encode()

   if err != nil {
      t.Fatal(err)
   }

   reqFail, err := http.NewRequest("GET", "/scanAndPushInbox", nil)
   qF := reqFail.URL.Query()
   qF.Add(ActionsKey, reqBodyFail.Actions)
   qF.Add(RolesKey, reqBodyFail.Roles)
   qF.Add(AwardTypesKey, reqBodyFail.AwardTypes)
   qF.Add(CampaignIdsKey, reqBodyFail.CampaignIDs)
   reqFail.URL.RawQuery = qF.Encode()

   if err != nil {
      t.Fatal(err)
   }

   type args struct {
      w   *httptest.ResponseRecorder      r   *http.Request      stt int   }
   tests := []struct {
      name string      args args   }{
      {name: "Happy case", args: args{
         w:   httptest.NewRecorder(),
         r:   reqSucces,
         stt: 1,
      }},
      {name: "Fail case", args: args{
         w:   httptest.NewRecorder(),
         r:   reqFail,
         stt: 2,
      }},
   }
   for _, tt := range tests {
      t.Run(tt.name, func(t *testing.T) {
         handler := http.HandlerFunc(scanAndPushMsg)
         handler.ServeHTTP(tt.args.w, tt.args.r.WithContext(ctx))
         switch tt.args.stt {
         case 1:
            if status := tt.args.w.Code; status != http.StatusOK {
               t.Errorf("handler returned wrong status code: got %v want %v",
                  status, http.StatusOK)
            }
         case 2:
            if status := tt.args.w.Code; status != http.StatusInternalServerError {
               t.Errorf("handler returned wrong status code: got %v want %v",
                  status, http.StatusInternalServerError)
            }

         }

      })
   }
}