review-me-v2

.gitignore

@@ -13,3 +13,7 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+# Ignore environment files
+.env
+.idea/

README.md

@@ -1 +1,102 @@
-# deveui-cli
+<br />
+<div align="center">
+  <a href="https://machinemax.com/">
+    <img src="images/logo.jpeg" alt="MachineMax Logo" width="200" height="200">
+  </a>
+
+  <h1 align="center">DevEUI CLI</h1>
+
+  <p align="center">
+    <h2 align="center">A Golang program for concurrently registering DevEUI identifiers for MachineMax.</h2>
+  </p>
+</div>
+
+## About MachineMax DevEUI
+
+Each MachineMax sensor has a unique 16-character (hex) identifier called a DevEUI. As part of
+the manufacturing process, it is written onto the internal storage of the sensor. The DevEUI is
+also printed on a label on the side of the sensor alongside a 5-character code (the last 5
+characters of the DevEUI). For example, a DevEUI of 78111FFFE452555B would have a short
+code of 2555B.
+
+The sensors communicate with the MachineMax cloud though a LoRaWAN provider and the
+LoRaWAN provider uses the DevEUI to identify the sensor. This means we first have to register
+the DevEUI with the provider before we can use it. We pay for every device registered with the
+LoRaWAN provider, so it is important that we only register DevEUIs that we use.
+
+When a customer registers a new sensor, they will enter the 5-character short-form code instead
+of the full DevEUI, so it is essential that each DevEUI in the batch has a unique 5-char code (for
+lookups).
+
+### Built With
+
+* Golang
+* Docker
+
+## Getting Started
+
+To run this code, we first need a `.env` file in the root of the project. Once this is done, add these vars:
+
+```
+BASE_URL=http://europe-west1-machinemax-dev-d524.cloudfunctions.net
+TIMEOUT=30000
+CODE_REGISTRATION_LIMIT=100
+```
+
+### Prerequisites
+
+- You will need Golang to run this program which can be downloaded at: [https://go.dev/](https://go.dev/)
+- This program can also be run using docker, this can be downloaded at: [https://www.docker.com/](https://www.docker.com/)
+
+## Usage
+
+Then to run locally, use: `go run main.go`.
+
+Alternatively, this code can also be run via docker. To build the docker image use: 
+```
+docker build -t deveui-cli . --build-arg BASE_URL=${BASE_URL} --build-arg TIMEOUT=${TIMEOUT} --build-arg CODE_REGISTRATION_LIMIT=${CODE_REGISTRATION_LIMIT}.
+```
+
+To run the docker image: 
+```
+docker run deveui-cli
+```
+
+To run the tests use: 
+```
+go test ./...
+``` 
+To check code coverage: 
+```
+go test -coverprofile=coverage.out ./... ; go tool cover -html=coverage.out
+```
+
+And to run benchmark tests for CPU and memory consumption:
+```
+go test -bench=. -benchmem
+```
+
+Finally to check for race conditions, use: 
+```
+go test -race ./...
+```
+
+## Checklist
+
+- [x] Implement solution
+- [x] Write unit tests
+- [x] Write readme
+- [ ] More unit tests around unhappy paths for higher code coverage
+- [ ] Discuss with engineers how to improve code
+
+## Contact
+
+Email - nickgowdy87@gmail.com
+
+Website <a href="http://www.nickgowdy.com/" target="_blank">http://www.nickgowdy.com/</a>
+
+Github <a href="https://github.com/nickgowdy" target="_blank">https://github.com/nickgowdy</a>
+
+
+
+

client/lorawan.go

@@ -0,0 +1,67 @@
+package client
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/NickGowdy/deveui-cli/device"
+)
+
+// Client used to communicate to external services
+type Client interface {
+	Do(*http.Request) (resp *http.Response, err error)
+}
+
+// LoraWAN used to communicate to LoRaWAN external system
+type LoraWAN struct {
+	baseURL string
+	client  Client
+}
+
+func NewLoraWAN(baseURL string, client Client) *LoraWAN {
+	return &LoraWAN{
+		baseURL: baseURL,
+		client:  client,
+	}
+}
+
+const endpoint = "/sensor-onboarding-sample" // endpoint for saving DevEUI via LoRaWAN
+
+// RegisterDevice registers new device using LoraWAN external service
+func (l *LoraWAN) RegisterDevice(ctx context.Context) (*device.Device, error) {
+	device := device.NewDevice()
+	identifier := device.GetIdentifier()
+	b := new(bytes.Buffer)
+	reqBody := map[string]string{"Deveui": identifier}
+
+	err := json.NewEncoder(b).Encode(&reqBody)
+	if err != nil {
+		return nil, err
+	}
+
+	fullUrl := l.baseURL + endpoint
+	req, err := http.NewRequestWithContext(ctx, "POST", fullUrl, b)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := l.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusOK {
+		return device, nil
+	} else {
+		return nil, errors.New(resp.Status)
+	}
+}

client/lorawan_test.go

@@ -0,0 +1,95 @@
+package client
+
+import (
+	"net/http"
+)
+
+type MockClient struct {
+	DoFunc func(*http.Request) (resp *http.Response, err error)
+}
+
+// func TestLorawanClientHappyPath(t *testing.T) {
+// 	mockClient := &MockClient{
+// 		DoFunc: func(*http.Request) (resp *http.Response, err error) {
+// 			return &http.Response{}, nil
+// 		},
+// 	}
+
+// 	loraWAN := NewLoraWAN("www.example.com", mockClient)
+
+// 	b := new(bytes.Buffer)
+// 	reqBody := map[string]string{"Deveui": "Abcde"}
+
+// 	_ = json.NewEncoder(b).Encode(&reqBody)
+
+// 	ctx, cancel := context.WithCancel(context.Background())
+
+// 	if cancel == nil {
+// 		t.Errorf("cancel should not be nil but is: %v", cancel)
+// 	}
+
+// 	resp, err := loraWAN.DoPost(b, ctx)
+
+// 	if err != nil {
+// 		t.Errorf("err should be nil but is: %s", err.Error())
+// 	}
+// 	defer resp.Body.Close()
+
+// 	if resp.StatusCode != 200 {
+// 		t.Errorf("resp should be nil but is: %d", resp.StatusCode)
+// 	}
+
+// 	body, _ := io.ReadAll(resp.Body)
+// 	val := string(body)
+
+// 	if strings.TrimSpace(val) != "true" {
+// 		t.Errorf("body should equal true but is: %d", body)
+// 	}
+// }
+
+// func TestNewLoraWanClient(t *testing.T) {
+// 	client := &http.Client{
+// 		Timeout: 30 * time.Second,
+// 	}
+// 	t.Parallel()
+// 	type args struct {
+// 		timeout time.Duration
+// 	}
+// 	tests := []struct {
+// 		name string
+// 		args args
+// 		want *LoraWAN
+// 	}{
+// 		{
+// 			name: "create-new-lorawan-client",
+// 			args: args{
+// 				timeout: 30,
+// 			},
+// 			want: &LoraWAN{
+// 				baseURL: "https://www.example.com",
+// 				client:  client,
+// 			},
+// 		},
+// 	}
+// 	for _, tt := range tests {
+// 		tt := tt // it is important to capture range variable
+// 		t.Run(tt.name, func(t *testing.T) {
+// 			t.Parallel() // this makes sure that all cases from the table here are executed in parallel
+// 			if got := NewLoraWAN("https://www.example.com", client); !reflect.DeepEqual(got, tt.want) {
+// 				t.Errorf("NewLoraWanClient() = %v, want %v", got, tt.want)
+// 			}
+// 		})
+// 	}
+// }
+
+// func (m *MockClient) Do(*http.Request) (resp *http.Response, err error) {
+// 	b := new(bytes.Buffer)
+// 	reqBody := true
+
+// 	_ = json.NewEncoder(b).Encode(&reqBody)
+// 	return &http.Response{
+// 			StatusCode: http.StatusOK,
+// 			Body:       io.NopCloser(b),
+// 			Status:     "200 OK"},
+// 		nil
+// }

device/device.go

@@ -0,0 +1,65 @@
+package device
+
+import (
+	"crypto/rand"
+	"fmt"
+	"log"
+	"math/big"
+)
+
+const (
+	AllowedChars = "ABCDEF0123456789" // accepted chars used to make up DevEUI
+	DevEuiLength = 16                 // valid DevEUI is string of length 16
+)
+
+type Device struct {
+	identifier string
+	code       string
+}
+
+// NewDevice Build a new device with DevEUI identifier and code values.
+//
+// # Example
+//
+//	1CEB0080F074F750 4F750
+func NewDevice() *Device {
+	hex, err := generateHexString()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return &Device{
+		identifier: hex,
+		code:       hex[len(hex)-5:],
+	}
+}
+
+func (d Device) GetIdentifier() string {
+	return d.identifier
+}
+
+func (d Device) GetCode() string {
+	return d.code
+}
+
+func (d Device) Print() {
+	fmt.Printf("device has identifier: %s and code: %s\n", d.identifier, d.code)
+}
+
+// Generate valid DevEUI identifier value.
+//
+// # Example
+//
+//	1CEB0080F074F750
+func generateHexString() (string, error) {
+	max := big.NewInt(int64(len(AllowedChars)))
+	b := make([]byte, DevEuiLength)
+	for i := range b {
+		n, err := rand.Int(rand.Reader, max)
+		if err != nil {
+			return "", err
+		}
+		b[i] = AllowedChars[n.Int64()]
+	}
+	return string(b), nil
+}