routebuildermdl_test.go

package routebuildermdl

import (
	"bytes"
	"mime/multipart"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/tidwall/gjson"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/servicebuildermdl"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"

	"github.com/stretchr/testify/assert"

	"github.com/gin-gonic/gin"
)

var router *gin.Engine

func DummyService(data *gjson.Result) (interface{}, error) {
	return "success", nil
}

func RDummyService(data *gjson.Result) (interface{}, error) {
	return "success", nil
}

func RBDummyService(data *gjson.Result) (interface{}, error) {
	return "success", nil
}
func MultiparService(form *multipart.Form) (interface{}, error) {
	return "success", nil
}

type testBl struct {
	servicebuildermdl.AbstractBusinessLogicHolder
}

func GetBLHolder() *testBl {
	test := testBl{}
	test.New()
	return &test
}

// func MasterService() {
// 	// test := GetBLHolder()
// 	// sb := servicebuildermdl.GetSB("MasterService", &test.AbstractBusinessLogicHolder).
// 	// 	AddStep("Test -1", "", nil, nil, nil)
// 	// RegisterMasterService("MasterService", sb, true, true)

// }
func init() {
	router = gin.New()
	o := router.Group("/o")
	r := router.Group("/r")
	c := r.Group("/c")
	Init(o, r, c)
	CreateResponseHeader("DummyService").
		EnableReponseCache().
		AddMethod("test", nil).
		SetResponseHeader()
	CreateResponseHeader("RDummyService").SetResponseHeader()
	RegisterNormalService("DummyService", DummyService, false, false)
	RegisterNormalService("RDummyService", RDummyService, true, false)
	RegisterNormalService("RBDummyService", RBDummyService, true, true)
	RegisterFormBasedService("MultiparService", MultiparService, true, true)
	CreateResponseHeader("DummyService").
		DisableReponseCache().
		SetResponseHeader()
	// MasterService()
}

func Test_OpenHandler(t *testing.T) {
	login := `
	{
		"loginId": "demo",
		"password": "demo"
	}
	`
	req, _ := http.NewRequest("POST", "/o/mql", bytes.NewBuffer([]byte(login)))
	req.Header.Set("Service-Header", "DummyService")
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)

	assert.Equal(t, resp.Code, 200)
}

func Test_RestrictedHandler(t *testing.T) {
	login := `
	{
		"loginId": "demo",
		"password": "demo"
	}
	`
	req, _ := http.NewRequest("POST", "/r/mql", bytes.NewBuffer([]byte(login)))
	req.Header.Set("Service-Header", "RDummyService")
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)

	assert.Equal(t, resp.Code, 200)
}

func Test_RoleBasedHandler(t *testing.T) {
	login := `
	{
		"loginId": "demo",
		"password": "demo"
	}
	`
	req, _ := http.NewRequest("POST", "/r/c/mql", bytes.NewBuffer([]byte(login)))
	req.Header.Set("Service-Header", "RBDummyService")
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)

	assert.Equal(t, resp.Code, 200)
}

func Test1_RestrictedHandler(t *testing.T) {
	login := `
	{
		"loginId": "demo",
		"password": "demo"
	}
	`
	req, _ := http.NewRequest("POST", "/r/c/mql", bytes.NewBuffer([]byte(login)))
	req.Header.Set("Service-Header", "RDummyService")
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)

	assert.Equal(t, resp.Code, 417)
}
func Test2_RestrictedHandler(t *testing.T) {
	errormdl.IsTestingNegetiveCaseOn2 = true
	login := `
	{
		"loginId": "demo",
		"password": "demo"
	}
	`
	req, _ := http.NewRequest("POST", "/r/c/mql", bytes.NewBuffer([]byte(login)))
	req.Header.Set("Service-Header", "RDummyService")
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)
	errormdl.IsTestingNegetiveCaseOn2 = true

	assert.Equal(t, resp.Code, 417)
}

func Test1_MultipartHandler(t *testing.T) {
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, _ := writer.CreateFormFile("file", "tmp.json")
	part.Write([]byte("tmp data"))
	writer.Close()
	req, _ := http.NewRequest("POST", "/r/c/mql", body)
	req.Header.Set("Service-Header", "MultiparService")
	req.Header.Add("Content-Type", writer.FormDataContentType())
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)

	assert.Equal(t, resp.Code, 200)
}

func Test2_MultipartHandler(t *testing.T) {
	errormdl.IsTestingNegetiveCaseOn = true
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, _ := writer.CreateFormFile("file", "tmp.json")
	part.Write([]byte("tmp data"))
	writer.Close()
	req, _ := http.NewRequest("POST", "/r/c/mql", body)
	req.Header.Set("Service-Header", "MultiparService")
	req.Header.Add("Content-Type", writer.FormDataContentType())
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)
	errormdl.IsTestingNegetiveCaseOn = false

	assert.Equal(t, resp.Code, 417)
}

func Test3_MultipartHandler(t *testing.T) {
	errormdl.IsTestingNegetiveCaseOn1 = true
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, _ := writer.CreateFormFile("file", "tmp.json")
	part.Write([]byte("tmp data"))
	writer.Close()
	req, _ := http.NewRequest("POST", "/r/c/mql", body)
	req.Header.Set("Service-Header", "MultiparService")
	req.Header.Add("Content-Type", writer.FormDataContentType())
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)
	errormdl.IsTestingNegetiveCaseOn1 = false

	assert.Equal(t, resp.Code, 417)
}
func Test4_MultipartHandler(t *testing.T) {
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, _ := writer.CreateFormFile("file", "tmp.json")
	part.Write([]byte("tmp data"))
	writer.Close()
	req, _ := http.NewRequest("POST", "/r/c/mql", body)
	req.Header.Set("Service-Header", "MultiparService")
	// req.Header.Add("Content-Type", writer.FormDataContentType())
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)

	assert.Equal(t, resp.Code, 417)
}

func Test_MasterService(t *testing.T) {

	req, _ := http.NewRequest("POST", "/r/c/mql", nil)
	req.Header.Set("Service-Header", "MasterService")
	resp := httptest.NewRecorder()
	router.ServeHTTP(resp, req)

	assert.Equal(t, resp.Code, 417)
}