Imrove code coverage (#32)

* Improve code coverage

.gitignore

@@ -1,2 +1,3 @@
 /.idea
 /node_modules
+/coverage.out

keycloak.go

@@ -166,14 +166,30 @@ func NewBackendKeycloak(host string, realm string, clientId string, secret strin
 	return &k
 }
 
-// MiddlewareReqHandlerFunc is a middleware that checks if the request is authorized
-func (kc *Keycloak) MiddlewareReqHandlerFunc(w http.ResponseWriter, r *http.Request) (*http.Request, error) {
+// getTokenFromRequest returns token from request
+func (kc *Keycloak) getTokenFromRequest(r *http.Request) (string, error) {
+	if r == nil {
+		return "", errors.New("request is nil")
+	}
 	auth := r.Header.Get("Authorization")
 	if !strings.HasPrefix(auth, "Bearer ") {
-		http.Error(w, "\"Invalid Authorization Header\"", http.StatusBadRequest)
+		return "", errors.New("invalid authorization header")
+	}
+
+	bearer := strings.TrimPrefix(auth, "Bearer ")
+	if bearer == "" {
+		return "", errors.New("empty bearer token")
+	}
+	return bearer, nil
+}
+
+// MiddlewareReqHandlerFunc is a middleware that checks if the request is authorized
+func (kc *Keycloak) MiddlewareReqHandlerFunc(w http.ResponseWriter, r *http.Request) (*http.Request, error) {
+	token, err := kc.getTokenFromRequest(r)
+	if err != nil {
+		http.Error(w, "\"Unauthorized\"", http.StatusUnauthorized)
 		return r, errors.New("stop")
 	}
-	token := strings.TrimPrefix(auth, "Bearer ")
 
 	_permissions, err := kc.getResourcesPermissions(token)
 	if err != nil {

keycloak_test.go

@@ -0,0 +1,115 @@
+package entkit
+
+import (
+	"github.com/Nerzal/gocloak/v12"
+	"github.com/stretchr/testify/assert"
+	"net/http"
+	"testing"
+)
+
+// test for entkit.NewKeycloak()
+func TestNewKeycloak(t *testing.T) {
+	assert := assert.New(t)
+	auth := &Auth{Extension: &Extension{}}
+	assert.Equal(
+		*NewKeycloak(auth, KeycloakHost("host")).Host,
+		"host",
+	)
+}
+
+// test for entkit.KeycloakHost()
+func TestKeycloakHost(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	assert.Nil(KeycloakHost("host")(keycloak))
+	assert.Equal(*keycloak.Host, "host")
+}
+
+// test for entkit.KeycloakRealm()
+func TestKeycloakRealm(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	assert.Nil(KeycloakRealm("realm")(keycloak))
+	assert.Equal(*keycloak.Realm, "realm")
+}
+
+// test for entkit.KeycloakMasterAdminCredentials()
+func TestKeycloakMasterAdminCredentials(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	assert.Nil(KeycloakMasterAdminCredentials("user", "pass")(keycloak))
+	assert.Equal(*keycloak.MasterAdminUsername, "user")
+	assert.Equal(*keycloak.MasterAdminPassword, "pass")
+}
+
+// test for entkit.KeycloakMasterRealm()
+func TestKeycloakMasterRealm(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	assert.Nil(KeycloakMasterRealm("realm")(keycloak))
+	assert.Equal(*keycloak.MasterRealm, "realm")
+}
+
+// test for entkit.KeycloakGeneratedAdminCredentials()
+func TestKeycloakGeneratedAdminCredentials(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	assert.Nil(KeycloakGeneratedAdminCredentials("admin", "pass")(keycloak))
+	assert.Equal(*keycloak.AdminUsername, "admin")
+	assert.Equal(*keycloak.AdminPassword, "pass")
+}
+
+// unit test for entkit.KeycloakBackendClientConfig
+func TestKeycloakBackendClientConfig(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	cConfig := gocloak.Client{ClientID: StringP("test")}
+	assert.Nil(KeycloakBackendClientConfig(cConfig)(keycloak))
+	assert.Equal(*keycloak.BackendClientConfig.ClientID, "test")
+}
+
+// unit test for entkit.KeycloakFrontendClientConfig
+func TestKeycloakFrontendClientConfig(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	cConfig := gocloak.Client{ClientID: StringP("test")}
+	assert.Nil(KeycloakFrontendClientConfig(cConfig)(keycloak))
+	assert.Equal(*keycloak.FrontendClientConfig.ClientID, "test")
+}
+
+// unit test for entkit.NewBackendKeycloak
+func TestNewBackendKeycloak(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal(*NewBackendKeycloak("test", "realm", "cid", "secret").Host, "test")
+}
+
+// unit test for Keycloak.getTokenFromRequest
+func TestKeycloak_getTokenFromRequest(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	token, err := keycloak.getTokenFromRequest(nil)
+	assert.Equal(token, "")
+	assert.EqualError(err, "request is nil")
+}
+
+// unit test for Keycloak.getTokenFromRequest when token is not found
+func TestKeycloak_getTokenFromRequest_EmptyBearerToken(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	token, err := keycloak.getTokenFromRequest(&http.Request{Header: map[string][]string{
+		"Authorization": {"Bearer "},
+	}})
+	assert.Equal(token, "")
+	assert.EqualError(err, "empty bearer token")
+}
+
+// unit test for Keycloak.getTokenFromRequest when token is not found
+func TestKeycloak_getTokenFromRequest_BearerPrefixNotFoundInAuthorizationHeader(t *testing.T) {
+	assert := assert.New(t)
+	keycloak := &Keycloak{}
+	token, err := keycloak.getTokenFromRequest(&http.Request{Header: map[string][]string{
+		"Authorization": {"Bea___ "},
+	}})
+	assert.Equal(token, "")
+	assert.EqualError(err, "invalid authorization header")
+}

operation.go

@@ -44,7 +44,7 @@ func OperationWithFailMessage(message string) OperationOption {
 }
 
 // OperationWithFields sets fields
-func OperationWithFields(fields []string) OperationOption {
+func OperationWithFields(fields ...string) OperationOption {
 	return func(op *Operation) (err error) {
 		op.Fields = &fields
 		return nil

operation_test.go

@@ -0,0 +1,70 @@
+package entkit
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+// test for Refine.NewOperation()
+func TestRefineNewOperation(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal(&Operation{
+		Name: StringP("name"),
+	}, NewOperation("name"))
+}
+
+// test for Refine.OperationWithSuccessMessage()
+func TestRefineOperationWithSuccessMessage(t *testing.T) {
+	assert := assert.New(t)
+	operation := &Operation{}
+	assert.Nil(OperationWithSuccessMessage("msg")(operation))
+	assert.Equal(&Operation{SuccessMessage: StringP("msg")}, operation)
+}
+
+// test for Refine.OperationWithErrorMessage()
+func TestRefineOperationWithErrorMessage(t *testing.T) {
+	assert := assert.New(t)
+	operation := &Operation{}
+	assert.Nil(OperationWithFailMessage("msg")(operation))
+	assert.Equal(&Operation{FailMessage: StringP("msg")}, operation)
+}
+
+// test for Refine.OperationWithFields()
+func TestRefineOperationWithFields(t *testing.T) {
+	assert := assert.New(t)
+	operation := &Operation{}
+	assert.Nil(OperationWithFields("a", "b")(operation))
+	assert.Equal(&Operation{Fields: &[]string{"a", "b"}}, operation)
+}
+
+// test for Refine.OperationAsBulk()
+func TestRefineOperationAsBulk(t *testing.T) {
+	assert := assert.New(t)
+	operation := &Operation{}
+	assert.Nil(OperationAsBulk()(operation))
+	assert.Equal(&Operation{Single: BoolP(false), Bulk: BoolP(true)}, operation)
+}
+
+// test for Refine.OperationAsSingle()
+func TestRefineOperationAsSingle(t *testing.T) {
+	assert := assert.New(t)
+	operation := &Operation{}
+	assert.Nil(OperationAsSingle()(operation))
+	assert.Equal(&Operation{Bulk: BoolP(false), Single: BoolP(true)}, operation)
+}
+
+// test for Refine.OperationAsMutation()
+func TestRefineOperationAsMutation(t *testing.T) {
+	assert := assert.New(t)
+	operation := &Operation{}
+	assert.Nil(OperationAsMutation()(operation))
+	assert.Equal(BoolP(true), operation.Mutation)
+}
+
+// test for Refine.OperationAsQuery()
+func TestRefineOperationAsQuery(t *testing.T) {
+	assert := assert.New(t)
+	operation := &Operation{}
+	assert.Nil(OperationAsQuery()(operation))
+	assert.Equal(BoolP(true), operation.Query)
+}

refine_generator_test.go

@@ -0,0 +1,52 @@
+package entkit
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+// test for Refine.GetName()
+func TestRefineGetName(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal("refine", DefaultRefineAdapter.GetName())
+}
+
+// test for Refine.GetFS()
+func TestRefineGetFS(t *testing.T) {
+	assert := assert.New(t)
+	assert.NotNil(DefaultRefineAdapter.GetFS())
+}
+
+// test for Refine.GetTemplates()
+func TestRefineGetTemplates(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal([]string{
+		"refine-templates/Tsconfig.gojson",
+		"refine-templates/Eslintignore.goignore",
+		"refine-templates/Dockerignore.goignore",
+		"refine-templates/Eslintrc.gojson",
+		"refine-templates/Prettierignore.goignore",
+		"refine-templates/Prettierrc.gojson",
+		"refine-templates/Gitignore.goignore",
+		"refine-templates/NpmRC.goenv",
+		"refine-templates/Package.gojson",
+		"refine-templates/Index.gohtml",
+		"refine-templates/Header.gotsx",
+		"refine-templates/Index.gotsx",
+		"refine-templates/Login.gotsx",
+		"refine-templates/App.gotsx",
+		"refine-templates/Show.gotsx",
+		"refine-templates/Form.gotsx",
+		"refine-templates/Table.gotsx",
+		"refine-templates/List.gotsx",
+		"refine-templates/EdgesDiagram.gotsx",
+		"refine-templates/Routes.gotsx",
+		"refine-templates/DataProvider.gots",
+		"refine-templates/SearchComponent.gotsx",
+		"refine-templates/SorterEnums.gotsx",
+		"refine-templates/View.gotsx",
+		"refine-templates/Actions.gotsx",
+		"refine-templates/Helpers.gotsx",
+		"refine-templates/Diagram.gotsx",
+	}, DefaultRefineAdapter.GetTemplates())
+}

route_test.go

@@ -0,0 +1,24 @@
+package entkit
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+// test for entkit.NewRoute with testify/assert
+func TestNewRoute(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal(&Route{
+		Path:    StringP("pth"),
+		Element: StringP("elem"),
+		Index:   BoolP(true),
+	}, NewRoute("pth", "elem", RouteAsIndex()))
+}
+
+// test for entkit.RouteAsIndex with testify/assert
+func TestRouteAsIndex(t *testing.T) {
+	assert := assert.New(t)
+	route := &Route{}
+	assert.Nil(RouteAsIndex()(route))
+	assert.Equal(&Route{Index: BoolP(true)}, route)
+}

server_generator_test.go

@@ -0,0 +1,47 @@
+package entkit
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+// test for ServerAdapter.GetName with testify/assert
+func TestServerAdapterGetName(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal("server", DefaultServerAdapter.GetName())
+}
+
+// test for ServerAdapter.GetFS with testify/assert
+func TestServerAdapterGetFS(t *testing.T) {
+	assert := assert.New(t)
+	assert.NotNil(DefaultServerAdapter.GetFS())
+}
+
+// test for entkit.ServerAdapter.GetTemplates with testify/assert
+func TestServerAdapterGetTemplates(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal([]string{
+		"server-templates/Gitignore.goignore",
+		"server-templates/Main.tmpl",
+		"server-templates/Embed-fs.tmpl",
+		"server-templates/Dockerfile.godockerfile",
+		"server-templates/Dockerignore.goignore",
+		"server-templates/Docker-compose.goyaml",
+	}, DefaultServerAdapter.GetTemplates())
+}
+
+// test for entkit.ServerAdapter.BeforeGen with testify/assert
+func TestServerAdapterBeforeGen(t *testing.T) {
+	assert := assert.New(t)
+	assert.Nil(DefaultServerAdapter.BeforeGen(&Generator{
+		Extension: &Extension{},
+	}))
+}
+
+// test for entkit.ServerAdapter.CommandAfterGen with testify/assert
+func TestServerAdapterCommandAfterGen(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal("go fmt", DefaultServerAdapter.CommandAfterGen(&Generator{
+		Extension: &Extension{},
+	}))
+}

typescript_generator_test.go

@@ -0,0 +1,24 @@
+package entkit
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+// test for TypescriptAdapter.GetName with testify/assert
+func TestTypescriptAdapterGetName(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal("typescript", DefaultTypescriptAdapter.GetName())
+}
+
+// test for TypescriptAdapter.GetFS with testify/assert
+func TestTypescriptAdapterGetFS(t *testing.T) {
+	assert := assert.New(t)
+	assert.NotNil(DefaultTypescriptAdapter.GetFS())
+}
+
+// test for TypescriptAdapter.GetTemplates with testify/assert
+func TestTypescriptAdapterGetTemplates(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal([]string{"typescript-templates/Typedefs.gots"}, DefaultTypescriptAdapter.GetTemplates())
+}