Comfortstat

SunButton/SunButton.go

@@ -0,0 +1,135 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/usecases"
+)
+
+func main() {
+	// Prepare for graceful shutdown
+	ctx, cancel := context.WithCancel(context.Background()) // Create a context that can be cancelled
+	defer cancel()                                          // Make sure all paths cancel the context to avoid context leak
+
+	// Instantiate the System
+	sys := components.NewSystem("SunButton", ctx)
+
+	// Instantiate the Capsule
+	sys.Husk = &components.Husk{
+		Description: "Is a controller for a consumed button based on a consumed time of day. Powered by SunriseSunset.io",
+		Certificate: "ABCD",
+		Details:     map[string][]string{"Developer": {"Arrowhead"}},
+		ProtoPort:   map[string]int{"https": 0, "http": 8670, "coap": 0},
+		InfoLink:    "https://github.com/lmas/d0020e_code/tree/master/SunButton",
+	}
+
+	// Instantiate a template unit asset
+	assetTemplate := initTemplate()
+	assetName := assetTemplate.GetName()
+	sys.UAssets[assetName] = &assetTemplate
+
+	// Configure the system
+	rawResources, servsTemp, err := usecases.Configure(&sys)
+	if err != nil {
+		log.Fatalf("Configuration error: %v\n", err)
+	}
+	sys.UAssets = make(map[string]*components.UnitAsset) // Clear the unit asset map (from the template)
+	for _, raw := range rawResources {
+		var uac UnitAsset
+		if err := json.Unmarshal(raw, &uac); err != nil {
+			log.Fatalf("Resource configuration error: %+v\n", err)
+		}
+		ua, startup := newUnitAsset(uac, &sys, servsTemp)
+		startup()
+		sys.UAssets[ua.GetName()] = &ua
+	}
+
+	// Generate PKI keys and CSR to obtain a authentication certificate from the CA
+	usecases.RequestCertificate(&sys)
+
+	// Register the (system) and its services
+	usecases.RegisterServices(&sys)
+
+	// Start the http handler and server
+	go usecases.SetoutServers(&sys)
+
+	// Wait for shutdown signal and gracefully close properly goroutines with context
+	<-sys.Sigs // Wait for a SIGINT (Crtl+C) signal
+	fmt.Println("\nShutting down system", sys.Name)
+	cancel()                    // Cancel the context, signaling the goroutines to stop
+	time.Sleep(2 * time.Second) // Allow the go routines to be executed, which might take more time then the main routine to end
+}
+
+// Serving handles the resource services. NOTE: It expects those names from the request URL path
+func (t *UnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
+	switch servicePath {
+	case "ButtonStatus":
+		t.httpSetButton(w, r)
+	case "Latitude":
+		t.httpSetLatitude(w, r)
+	case "Longitude":
+		t.httpSetLongitude(w, r)
+	default:
+		http.Error(w, "Invalid service request [Do not modify the services subpath in the configuration file]", http.StatusBadRequest)
+	}
+}
+
+// All these functions below handles HTTP "PUT" or "GET" requests to modify or retrieve the latitude and longitude and the state of the button
+// For the PUT case - the "HTTPProcessSetRequest(w, r)" is called to prosses the data given from the user and if no error,
+// call the set functions in thing.go with the value witch updates the value in the struct
+func (rsc *UnitAsset) httpSetButton(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "PUT":
+		sig, err := usecases.HTTPProcessSetRequest(w, r)
+		if err != nil {
+			http.Error(w, "request incorrectly formatted", http.StatusBadRequest)
+			return
+		}
+		rsc.setButtonStatus(sig)
+	case "GET":
+		signalErr := rsc.getButtonStatus()
+		usecases.HTTPProcessGetRequest(w, r, &signalErr)
+	default:
+		http.Error(w, "Method is not supported.", http.StatusNotFound)
+	}
+}
+
+func (rsc *UnitAsset) httpSetLatitude(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "PUT":
+		sig, err := usecases.HTTPProcessSetRequest(w, r)
+		if err != nil {
+			http.Error(w, "request incorrectly formatted", http.StatusBadRequest)
+			return
+		}
+		rsc.setLatitude(sig)
+	case "GET":
+		signalErr := rsc.getLatitude()
+		usecases.HTTPProcessGetRequest(w, r, &signalErr)
+	default:
+		http.Error(w, "Method is not supported.", http.StatusNotFound)
+	}
+}
+
+func (rsc *UnitAsset) httpSetLongitude(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "PUT":
+		sig, err := usecases.HTTPProcessSetRequest(w, r)
+		if err != nil {
+			http.Error(w, "request incorrectly formatted", http.StatusBadRequest)
+			return
+		}
+		rsc.setLongitude(sig)
+	case "GET":
+		signalErr := rsc.getLongitude()
+		usecases.HTTPProcessGetRequest(w, r, &signalErr)
+	default:
+		http.Error(w, "Method is not supported.", http.StatusNotFound)
+	}
+}

SunButton/SunButton_test.go

@@ -0,0 +1,215 @@
+package main
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestHttpSetButton(t *testing.T) {
+	ua := initTemplate().(*UnitAsset)
+
+	// Good case test: GET
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "http://172.30.106.39:8670/SunButton/Button/ButtonStatus", nil)
+	goodStatusCode := 200
+	ua.httpSetButton(w, r)
+	// calls the method and extracts the response and save is in resp for the upcoming tests
+	resp := w.Result()
+	if resp.StatusCode != goodStatusCode {
+		t.Errorf("expected good status code: %v, got %v", goodStatusCode, resp.StatusCode)
+	}
+	body, _ := io.ReadAll(resp.Body)
+	// this is a simple check if the JSON response contains the specific value/unit/version
+	value := strings.Contains(string(body), `"value": 0.5`)
+	unit := strings.Contains(string(body), `"unit": "bool"`)
+	version := strings.Contains(string(body), `"version": "SignalA_v1.0"`)
+	// check results from above
+	if value != true {
+		t.Errorf("expected the statement to be true!")
+	}
+	if unit != true {
+		t.Errorf("expected the unit statement to be true!")
+	}
+	if version != true {
+		t.Errorf("expected the version statement to be true!")
+	}
+
+	//Godd test case: PUT
+	// creates a fake request body with JSON data
+	w = httptest.NewRecorder()
+	fakebody := bytes.NewReader([]byte(`{"value": 0, "unit": "bool", "version": "SignalA_v1.0"}`))      // converts the Jason data so it can be read
+	r = httptest.NewRequest("PUT", "http://172.30.106.39:8670/SunButton/Button/ButtonStatus", fakebody) // simulating a put request from a user to update the button status
+	r.Header.Set("Content-Type", "application/json")                                                    // basic setup to prevent the request to be rejected.
+	ua.httpSetButton(w, r)
+
+	// save the response and read the body
+	resp = w.Result()
+	if resp.StatusCode != goodStatusCode {
+		t.Errorf("expected good status code: %v, got %v", goodStatusCode, resp.StatusCode)
+	}
+
+	//BAD case: PUT, if the fake body is formatted incorrectly
+
+	// creates a fake request body with JSON data
+	w = httptest.NewRecorder()
+	fakebody = bytes.NewReader([]byte(`{"123, "unit": "bool", "version": "SignalA_v1.0"}`))             // converts the Jason data so it can be read
+	r = httptest.NewRequest("PUT", "http://172.30.106.39:8670/SunButton/Button/ButtonStatus", fakebody) // simulating a put request from a user to update the button status
+	r.Header.Set("Content-Type", "application/json")                                                    // basic setup to prevent the request to be rejected.
+	ua.httpSetButton(w, r)
+	// save the response and read the body
+	resp = w.Result()
+	if resp.StatusCode == goodStatusCode {
+		t.Errorf("expected bad status code: %v, got %v", goodStatusCode, resp.StatusCode)
+	}
+	// Bad test case: default part of code
+	// force the case to hit default statement but alter the method
+	w = httptest.NewRecorder()
+	r = httptest.NewRequest("123", "http://172.30.106.39:8670/SunButton/Button/ButtonStatus", nil)
+	// calls the method and extracts the response and save is in resp for the upcoming tests
+	ua.httpSetButton(w, r)
+	resp = w.Result()
+	if resp.StatusCode != http.StatusNotFound {
+		t.Errorf("Expected the status to be bad but got: %v", resp.StatusCode)
+	}
+}
+
+func TestHttpSetLatitude(t *testing.T) {
+	ua := initTemplate().(*UnitAsset)
+
+	//Godd test case: PUT
+	// creates a fake request body with JSON data
+	w := httptest.NewRecorder()
+	fakebody := bytes.NewReader([]byte(`{"value": 65.584816, "unit": "Degrees", "version": "SignalA_v1.0"}`)) // converts the Jason data so it can be read
+	r := httptest.NewRequest("PUT", "http://172.30.106.39:8670/SunButton/Button/Latitude", fakebody)          // simulating a put request from a user to update the latitude
+	r.Header.Set("Content-Type", "application/json")                                                          // basic setup to prevent the request to be rejected.
+	goodStatusCode := 200
+	ua.httpSetLatitude(w, r)
+
+	// save the response and read the body
+	resp := w.Result()
+	if resp.StatusCode != goodStatusCode {
+		t.Errorf("expected good status code: %v, got %v", goodStatusCode, resp.StatusCode)
+	}
+
+	//BAD case: PUT, if the fake body is formatted incorrectly
+
+	// creates a fake request body with JSON data
+	w = httptest.NewRecorder()
+	fakebody = bytes.NewReader([]byte(`{"123, "unit": "Degrees", "version": "SignalA_v1.0"}`))      // converts the Jason data so it can be read
+	r = httptest.NewRequest("PUT", "http://172.30.106.39:8670/SunButton/Button/Latitude", fakebody) // simulating a put request from a user to update the latitude
+	r.Header.Set("Content-Type", "application/json")                                                // basic setup to prevent the request to be rejected.
+	ua.httpSetLatitude(w, r)
+	// save the response and read the body
+	resp = w.Result()
+	if resp.StatusCode == goodStatusCode {
+		t.Errorf("expected bad status code: %v, got %v", goodStatusCode, resp.StatusCode)
+	}
+	//Good test case: GET
+	w = httptest.NewRecorder()
+	r = httptest.NewRequest("GET", "http://172.30.106.39:8670/SunButton/Button/Latitude", nil)
+	goodStatusCode = 200
+	ua.httpSetLatitude(w, r)
+
+	// save the response and read the body
+	resp = w.Result()
+	if resp.StatusCode != goodStatusCode {
+		t.Errorf("expected good status code: %v, got %v", goodStatusCode, resp.StatusCode)
+	}
+	body, _ := io.ReadAll(resp.Body)
+	// this is a simple check if the JSON response contains the specific value/unit/version
+	value := strings.Contains(string(body), `"value": 65.584816`)
+	unit := strings.Contains(string(body), `"unit": "Degrees"`)
+	version := strings.Contains(string(body), `"version": "SignalA_v1.0"`)
+	// check the result from above
+	if value != true {
+		t.Errorf("expected the statement to be true!")
+	}
+	if unit != true {
+		t.Errorf("expected the unit statement to be true!")
+	}
+	if version != true {
+		t.Errorf("expected the version statement to be true!")
+	}
+	// bad test case: default part of code
+	// force the case to hit default statement but alter the method
+	w = httptest.NewRecorder()
+	r = httptest.NewRequest("666", "http://172.30.106.39:8670/SunButton/Button/Latitude", nil)
+	ua.httpSetLatitude(w, r)
+	resp = w.Result()
+	if resp.StatusCode != http.StatusNotFound {
+		t.Errorf("expected the status to be bad but got: %v", resp.StatusCode)
+	}
+}
+
+func TestHttpSetLongitude(t *testing.T) {
+	ua := initTemplate().(*UnitAsset)
+	//Godd test case: PUT
+
+	// creates a fake request body with JSON data
+	w := httptest.NewRecorder()
+	fakebody := bytes.NewReader([]byte(`{"value": 22.156704, "unit": "Degrees", "version": "SignalA_v1.0"}`)) // converts the Jason data so it can be read
+	r := httptest.NewRequest("PUT", "http://172.30.106.39:8670/SunButton/Button/Longitude", fakebody)         // simulating a put request from a user to update the longitude
+	r.Header.Set("Content-Type", "application/json")                                                          // basic setup to prevent the request to be rejected.
+	goodStatusCode := 200
+	ua.httpSetLongitude(w, r)
+
+	// save the response and read the body
+	resp := w.Result()
+	if resp.StatusCode != goodStatusCode {
+		t.Errorf("expected good status code: %v, got %v", goodStatusCode, resp.StatusCode)
+	}
+	//BAD case: PUT, if the fake body is formatted incorrectly
+
+	// creates a fake request body with JSON data
+	w = httptest.NewRecorder()
+	fakebody = bytes.NewReader([]byte(`{"123, "unit": "Degrees", "version": "SignalA_v1.0"}`))       // converts the Jason data so it can be read
+	r = httptest.NewRequest("PUT", "http://172.30.106.39:8670/SunButton/Button/Longitude", fakebody) // simulating a put request from a user to update the min temp
+	r.Header.Set("Content-Type", "application/json")                                                 // basic setup to prevent the request to be rejected.
+	ua.httpSetLongitude(w, r)
+
+	// save the response and read the body
+	resp = w.Result()
+	if resp.StatusCode == goodStatusCode {
+		t.Errorf("expected bad status code: %v, got %v", goodStatusCode, resp.StatusCode)
+	}
+	//Good test case: GET
+	w = httptest.NewRecorder()
+	r = httptest.NewRequest("GET", "http://172.30.106.39:8670/SunButton/Button/Longitude", nil)
+	goodStatusCode = 200
+	ua.httpSetLongitude(w, r)
+
+	// save the response and read the body
+	resp = w.Result()
+	if resp.StatusCode != goodStatusCode {
+		t.Errorf("expected good status code: %v, got %v", goodStatusCode, resp.StatusCode)
+	}
+	body, _ := io.ReadAll(resp.Body)
+	// this is a simple check if the JSON response contains the specific value/unit/version
+	value := strings.Contains(string(body), `"value": 22.156704`)
+	unit := strings.Contains(string(body), `"unit": "Degrees"`)
+	version := strings.Contains(string(body), `"version": "SignalA_v1.0"`)
+	if value != true {
+		t.Errorf("expected the statement to be true!")
+	}
+	if unit != true {
+		t.Errorf("expected the unit statement to be true!")
+	}
+	if version != true {
+		t.Errorf("expected the version statement to be true!")
+	}
+	// bad test case: default part of code
+
+	// force the case to hit default statement but alter the method
+	w = httptest.NewRecorder()
+	r = httptest.NewRequest("666", "http://172.30.106.39:8670/SunButton/Button/Longitude", nil)
+	ua.httpSetLongitude(w, r)
+	//save the response
+	resp = w.Result()
+	if resp.StatusCode != http.StatusNotFound {
+		t.Errorf("expected the status to be bad but got: %v", resp.StatusCode)
+	}
+}