make lib w/ no dep to mainflux

Author: b-2-83

README.md

@@ -6,8 +6,8 @@ logging and debugging and various other purposes.
 
 ## Usage
 ```bash
-go get github.com/mainflux/mproxy
-cd $(GOPATH)/github.com/mainflux/mproxy
+go get github.com/objenious/mproxy
+cd $(GOPATH)/github.com/objenious/mproxy
 make
 ./mproxy
 ```

cmd/main.go

@@ -10,12 +10,12 @@ import (
 	"strconv"
 	"syscall"
 
-	mflog "github.com/mainflux/mainflux/logger"
-	"github.com/mainflux/mproxy/examples/simple"
-	"github.com/mainflux/mproxy/pkg/mqtt"
-	"github.com/mainflux/mproxy/pkg/session"
-	mptls "github.com/mainflux/mproxy/pkg/tls"
-	"github.com/mainflux/mproxy/pkg/websocket"
+	mflog "github.com/objenious/mproxy/logger"
+	"github.com/objenious/mproxy/examples/simple"
+	"github.com/objenious/mproxy/pkg/mqtt"
+	"github.com/objenious/mproxy/pkg/session"
+	mptls "github.com/objenious/mproxy/pkg/tls"
+	"github.com/objenious/mproxy/pkg/websocket"
 )
 
 const (

examples/simple/simple.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/mainflux/mainflux/logger"
-	"github.com/mainflux/mproxy/pkg/session"
+	"github.com/objenious/mproxy/logger"
+	"github.com/objenious/mproxy/pkg/session"
 )
 
 var _ session.Handler = (*Handler)(nil)

go.mod

@@ -1,11 +1,11 @@
-module github.com/mainflux/mproxy
+module github.com/objenious/mproxy
 
 go 1.14
 
 require (
 	github.com/eclipse/paho.mqtt.golang v1.2.0
+	github.com/go-kit/kit v0.10.0
 	github.com/google/uuid v1.1.1
 	github.com/gorilla/websocket v1.4.2
-	github.com/mainflux/mainflux v0.11.1-0.20200603183352-7f3e2c1b21ed
-	google.golang.org/genproto v0.0.0-20200604104852-0b0486081ffb // indirect
+	github.com/stretchr/testify v1.6.0
 )

go.sum

@@ -0,0 +1,63 @@
+package logger
+
+import (
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestUnmarshalText(t *testing.T) {
+	cases := map[string]struct {
+		input  string
+		output Level
+		err    error
+	}{
+		"select log level Not_A_Level": {"Not_A_Level", 0, ErrInvalidLogLevel},
+		"select log level Bad_Input":   {"Bad_Input", 0, ErrInvalidLogLevel},
+
+		"select log level debug": {"debug", Debug, nil},
+		"select log level DEBUG": {"DEBUG", Debug, nil},
+		"select log level info":  {"info", Info, nil},
+		"select log level INFO":  {"INFO", Info, nil},
+		"select log level warn":  {"warn", Warn, nil},
+		"select log level WARN":  {"WARN", Warn, nil},
+		"select log level Error": {"Error", Error, nil},
+		"select log level ERROR": {"ERROR", Error, nil},
+	}
+
+	for desc, tc := range cases {
+		var logLevel Level
+		err := logLevel.UnmarshalText(tc.input)
+		assert.Equal(t, tc.output, logLevel, fmt.Sprintf("%s: expected %s got %d", desc, tc.output, logLevel))
+		assert.Equal(t, tc.err, err, fmt.Sprintf("%s: expected %s got %d", desc, tc.err, err))
+
+	}
+
+}
+
+func TestLevelIsAllowed(t *testing.T) {
+	cases := map[string]struct {
+		requestedLevel Level
+		allowedLevel   Level
+		output         bool
+	}{
+		"log debug when level debug": {Debug, Debug, true},
+		"log info when level debug":  {Info, Debug, true},
+		"log warn when level debug":  {Warn, Debug, true},
+		"log error when level debug": {Error, Debug, true},
+		"log warn when level info":   {Warn, Info, true},
+		"log error when level warn":  {Error, Warn, true},
+		"log error when level error": {Error, Error, true},
+
+		"log debug when level error": {Debug, Error, false},
+		"log info when level error":  {Info, Error, false},
+		"log warn when level error":  {Warn, Error, false},
+		"log debug when level warn":  {Debug, Warn, false},
+		"log info when level warn":   {Info, Warn, false},
+		"log debug when level info":  {Debug, Info, false},
+	}
+	for desc, tc := range cases {
+		result := tc.requestedLevel.isAllowed(tc.allowedLevel)
+		assert.Equal(t, tc.output, result, fmt.Sprintf("%s: expected %t got %t", desc, tc.output, result))
+	}
+}

…thub.com/mainflux/mainflux/logger/doc.go logger/doc.govendor/github.com/mainflux/mainflux/logger/doc.go renamed to logger/doc.go vendor/github.com/mainflux/mainflux/logger/doc.go renamed to logger/doc.go

@@ -0,0 +1,126 @@
+// Copyright (c) Mainflux
+// SPDX-License-Identifier: Apache-2.0
+
+package logger_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"testing"
+
+	log "github.com/objenious/mproxy/logger"
+	"github.com/stretchr/testify/assert"
+)
+
+var _ io.Writer = (*mockWriter)(nil)
+var writer mockWriter
+var logger log.Logger
+var err error
+var output logMsg
+
+type mockWriter struct {
+	value []byte
+}
+
+func (writer *mockWriter) Write(p []byte) (int, error) {
+	writer.value = p
+	return len(p), nil
+}
+
+func (writer *mockWriter) Read() (logMsg, error) {
+	var output logMsg
+	err := json.Unmarshal(writer.value, &output)
+	return output, err
+}
+
+type logMsg struct {
+	Level   string `json:"level"`
+	Message string `json:"message"`
+}
+
+func TestDebug(t *testing.T) {
+	cases := map[string]struct {
+		input    string
+		logLevel string
+		output   logMsg
+	}{
+		"debug log ordinary string":             {"input_string", log.Debug.String(), logMsg{log.Debug.String(), "input_string"}},
+		"debug log empty string":                {"", log.Debug.String(), logMsg{log.Debug.String(), ""}},
+		"debug ordinary string lvl not allowed": {"input_string", log.Info.String(), logMsg{"", ""}},
+		"debug empty string lvl not allowed":    {"", log.Info.String(), logMsg{"", ""}},
+	}
+
+	for desc, tc := range cases {
+		writer = mockWriter{}
+		logger, err = log.New(&writer, tc.logLevel)
+		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", desc, err))
+		logger.Debug(tc.input)
+		output, err = writer.Read()
+		assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", desc, tc.output, output))
+	}
+}
+
+func TestInfo(t *testing.T) {
+	cases := map[string]struct {
+		input    string
+		logLevel string
+		output   logMsg
+	}{
+		"info log ordinary string":             {"input_string", log.Info.String(), logMsg{log.Info.String(), "input_string"}},
+		"info log empty string":                {"", log.Info.String(), logMsg{log.Info.String(), ""}},
+		"info ordinary string lvl not allowed": {"input_string", log.Warn.String(), logMsg{"", ""}},
+		"info empty string lvl not allowed":    {"", log.Warn.String(), logMsg{"", ""}},
+	}
+
+	for desc, tc := range cases {
+		writer = mockWriter{}
+		logger, err = log.New(&writer, tc.logLevel)
+		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", desc, err))
+		logger.Info(tc.input)
+		output, err = writer.Read()
+		assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", desc, tc.output, output))
+	}
+}
+
+func TestWarn(t *testing.T) {
+	cases := map[string]struct {
+		input    string
+		logLevel string
+		output   logMsg
+	}{
+		"warn log ordinary string":             {"input_string", log.Warn.String(), logMsg{log.Warn.String(), "input_string"}},
+		"warn log empty string":                {"", log.Warn.String(), logMsg{log.Warn.String(), ""}},
+		"warn ordinary string lvl not allowed": {"input_string", log.Error.String(), logMsg{"", ""}},
+		"warn empty string lvl not allowed":    {"", log.Error.String(), logMsg{"", ""}},
+	}
+
+	for desc, tc := range cases {
+		writer = mockWriter{}
+		logger, err = log.New(&writer, tc.logLevel)
+		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", desc, err))
+		logger.Warn(tc.input)
+		output, err = writer.Read()
+		assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", desc, tc.output, output))
+	}
+}
+
+func TestError(t *testing.T) {
+	cases := map[string]struct {
+		input  string
+		output logMsg
+	}{
+		"error log ordinary string": {"input_string", logMsg{log.Error.String(), "input_string"}},
+		"error log empty string":    {"", logMsg{log.Error.String(), ""}},
+	}
+
+	writer := mockWriter{}
+	logger, _ := log.New(&writer, log.Error.String())
+
+	for desc, tc := range cases {
+		logger.Error(tc.input)
+		output, err := writer.Read()
+		assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", desc, err))
+		assert.Equal(t, tc.output, output, fmt.Sprintf("%s: expected %s got %s", desc, tc.output, output))
+	}
+}