From 7a3bf8fbeee5342acb73218770570ceacf41f8e5 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 5 Jun 2025 14:15:16 +0200
Subject: [PATCH 001/186] Added Makefile, Github Actions and test template

---
 .github/workflows/main.yml | 43 ++++++++++++++++++++++++++++++++++++++
 Makefile                   | 36 +++++++++++++++++++++++++++++++
 usecases/test_sample.go    | 33 +++++++++++++++++++++++++++++
 3 files changed, 112 insertions(+)
 create mode 100644 .github/workflows/main.yml
 create mode 100644 Makefile
 create mode 100644 usecases/test_sample.go

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
new file mode 100644
index 0000000..4cd3683
--- /dev/null
+++ b/.github/workflows/main.yml
@@ -0,0 +1,43 @@
+name: Linters, Spellcheck, and Tests
+
+on:
+  push:
+  workflow_dispatch:
+
+jobs:
+  Linters:
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup go
+        uses: actions/setup-go@v5
+        with:
+          go-version: 1.23
+      - name: Install dependencies
+        run: make deps
+      - name: Run linters
+        run: make lint
+
+  Spellcheck:
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      - uses: actions/checkout@v4
+      - uses: crate-ci/typos@v1.29.7
+
+  Tests:
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup go
+        uses: actions/setup-go@v5
+        with:
+          go-version: 1.23
+      - name: Install dependencies
+        run: make deps
+      - name: Run tests
+        run: make test
+      - name: Report stats
+        run: make analyse
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..d7ce277
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,36 @@
+# Run tests and log the test coverage
+test:
+	go test -v -coverprofile=".cover.out" $$(go list ./... | grep -v /tmp)
+
+# Runs source code linters and catches common errors
+lint:
+	test -z $$(gofmt -l .) || (echo "Code isn't gofmt'ed!" && exit 1)
+	go vet $$(go list ./... | grep -v /tmp)
+	gosec -quiet -fmt=golint -exclude-dir="tmp" ./...
+	pointerinterface ./...
+
+# Runs spellchecker on the code and comments
+# This requires this tool to be installed from https://github.com/crate-ci/typos?tab=readme-ov-file
+# Example installation (if you have rust installed): cargo install typos-cli
+spellcheck:
+	typos .
+
+# Generate pretty coverage report
+analyse:
+	go tool cover -html=".cover.out" -o="cover.html"
+	@echo -e "\nCOVERAGE\n===================="
+	go tool cover -func=.cover.out
+	@echo -e "\nCYCLOMATIC COMPLEXITY\n===================="
+	gocyclo -avg -top 10 -ignore test.go .
+
+# Updates 3rd party packages and tools
+deps:
+	go mod download
+	go install github.com/securego/gosec/v2/cmd/gosec@latest
+	go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
+	go install code.larus.se/lmas/pointerinterface@latest
+
+# Clean up built binary and other temporary files (ignores errors from rm)
+clean:
+	go clean
+	rm .cover.out cover.html
diff --git a/usecases/test_sample.go b/usecases/test_sample.go
new file mode 100644
index 0000000..a7dfecd
--- /dev/null
+++ b/usecases/test_sample.go
@@ -0,0 +1,33 @@
+package usecases
+
+import (
+	"net/http"
+	"testing"
+)
+
+// mockTransport is used for replacing the default network Transport (used by
+// http.DefaultClient) and it will intercept network requests.
+type mockTransport struct {
+	resp *http.Response
+}
+
+func newMockTransport(resp *http.Response) mockTransport {
+	t := mockTransport{
+		resp: resp,
+	}
+	// Hijack the default http client so no actual http requests are sent over the network
+	http.DefaultClient.Transport = t
+	return t
+}
+
+// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
+// It prevents the request from being sent over the network and count how many times
+// a domain was requested.
+func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	t.resp.Request = req
+	return t.resp, nil
+}
+
+func sample(t *testing.T) {
+	return
+}

From 1a0bf9e3500e4a37ad05a1b31ff556e0522ea654 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 5 Jun 2025 14:17:59 +0200
Subject: [PATCH 002/186] Making sure tests run

---
 usecases/test_sample.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/test_sample.go b/usecases/test_sample.go
index a7dfecd..14ff4fb 100644
--- a/usecases/test_sample.go
+++ b/usecases/test_sample.go
@@ -28,6 +28,6 @@ func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err er
 	return t.resp, nil
 }
 
-func sample(t *testing.T) {
+func test_sample(t *testing.T) {
 	return
 }

From 9bac8c374977cf10408bf8045ba60992a07c19c5 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 5 Jun 2025 16:34:30 +0200
Subject: [PATCH 003/186] Fixed linter errors by adding error handlers,
 MinVersion for tls and read/write timeouts in server config

---
 usecases/authentication.go   | 22 ++++++++--
 usecases/cost.go             |  5 ++-
 usecases/docs.go             | 81 ++++++++++++++++--------------------
 usecases/provision.go        | 12 +++++-
 usecases/serversNhandlers.go | 25 +++++++----
 5 files changed, 87 insertions(+), 58 deletions(-)

diff --git a/usecases/authentication.go b/usecases/authentication.go
index 134ff25..8138fd9 100644
--- a/usecases/authentication.go
+++ b/usecases/authentication.go
@@ -93,6 +93,7 @@ func RequestCertificate(sys *components.System) {
 		Certificates:       []tls.Certificate{clientCert},
 		RootCAs:            caCertPool,
 		InsecureSkipVerify: false,
+		MinVersion:         tls.VersionTLS12,
 	}
 	sys.Husk.TlsConfig = tlsConfig
 
@@ -137,7 +138,11 @@ func sendCSR(sys *components.System, csrPEM []byte) (string, error) {
 
 	// Read the response body
 	buf := new(bytes.Buffer)
-	buf.ReadFrom(resp.Body)
+	_, err = buf.ReadFrom(resp.Body)
+	if err != nil {
+		log.Printf("Error while reading body: %v", err)
+		return "", err
+	}
 
 	return buf.String(), nil
 }
@@ -158,7 +163,14 @@ func getCACertificate(sys *components.System) (string, error) {
 	url := strings.TrimSuffix(coreUAurl, "ification") // the configuration file address to the CA includes the unit asset
 
 	// Make a GET request to the CA's endpoint
-	resp, err := http.Get(url)
+	// https://stackoverflow.com/questions/70281883/golang-untaint-url-variable-to-fix-gosec-warning-g107
+	//resp, err := http.Get(url)
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		log.Printf("Error creating NewRequest: %v", err)
+		return "", err
+	}
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return "", fmt.Errorf("failed to send request to CA: %w", err)
 	}
@@ -171,7 +183,11 @@ func getCACertificate(sys *components.System) (string, error) {
 
 	// Read the response body
 	buf := new(bytes.Buffer)
-	buf.ReadFrom(resp.Body)
+	_, err = buf.ReadFrom(resp.Body)
+	if err != nil {
+		log.Printf("Error while reading body: %v", err)
+		return "", err
+	}
 
 	return buf.String(), nil
 }
diff --git a/usecases/cost.go b/usecases/cost.go
index 1a3f1a2..888e8d5 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -94,7 +94,10 @@ func ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset
 		}
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
-		w.Write(payload)
+		_, err = w.Write(payload)
+		if err != nil {
+			log.Printf("Error while writing to response body for ACServices: %v", err)
+		}
 		return
 	case "PUT":
 		defer r.Body.Close()
diff --git a/usecases/docs.go b/usecases/docs.go
index 412b542..f2644a0 100644
--- a/usecases/docs.go
+++ b/usecases/docs.go
@@ -29,6 +29,7 @@ package usecases
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 	"strconv"
 	"strings"
@@ -39,102 +40,92 @@ import (
 // System Documentation (based on HATEOAS) provides an initial documentation on the system's web server of with hyperlinks to the services for browsers
 // HATEOAS is the acronym for Hypermedia as the Engine of Application State, using hyperlinks to navigate the API
 func SysHateoas(w http.ResponseWriter, req *http.Request, sys components.System) {
-	text := "<!DOCTYPE html><html><body>"
-	w.Write([]byte(text))
-	text = "<h1>System Description</h1>"
-	w.Write([]byte(text))
-	text = "<p>The system <b>" + sys.Name + "</b> " + sys.Husk.Description + "</p><br>"
-	w.Write([]byte(text))
-	text = "<a href=\"" + sys.Husk.InfoLink + "\">Online Documentation</a></p>"
-	w.Write([]byte(text))
-
-	text = "<p> The resource list is </p><ul>"
-	w.Write([]byte(text))
+	text := "<!DOCTYPE html><html><body>\n"
+	text += "<h1>System Description</h1>\n"
+	text += "<p>The system <b>" + sys.Name + "</b> " + sys.Husk.Description + "</p><br>\n"
+	text += "<a href=\"" + sys.Husk.InfoLink + "\">Online Documentation</a></p>\n"
+	text += "<p> The resource list is </p><ul>\n"
+
 	assetList := &sys.UAssets
 	for _, unitasset := range *assetList {
 		metaservice := ""
 		for key, values := range (*unitasset).GetDetails() {
 			metaservice += key + ": " + fmt.Sprintf("%v", values) + " "
 		}
-		resourceURI := "<li><b><a href=\"http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(sys.Husk.ProtoPort["http"]) + "/" + sys.Name + "/" + (*unitasset).GetName() + "/doc" + "\">" + (*unitasset).GetName() + "</a></b> with details " + metaservice + "</li>"
-		w.Write([]byte(resourceURI))
+		text += "<li><b><a href=\"http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(sys.Husk.ProtoPort["http"]) + "/" + sys.Name + "/" + (*unitasset).GetName() + "/doc" + "\">" + (*unitasset).GetName() + "</a></b> with details " + metaservice + "</li>\n"
 	}
 
-	text = "</ul> having the following services:<ul>"
-	w.Write([]byte(text))
+	text += "</ul> having the following services:<ul>\n"
 	servicesList := getServicesList(getFirstAsset(*assetList)[0])
 	for _, service := range servicesList {
 		metaservice := ""
 		for key, values := range service.Details {
 			metaservice += key + ": " + fmt.Sprintf("%v", values) + " "
 		}
-		serviceURI := "<li><b>" + service.Definition + "</b> with details: " + metaservice + "</li>"
-		w.Write([]byte(serviceURI))
+		text += "<li><b>" + service.Definition + "</b> with details: " + metaservice + "</li>\n"
 	}
 
-	text = "</ul> <p> The services can be accessed using the following protocols with their respective bound ports:</p><ul>"
-	w.Write([]byte(text))
+	text += "</ul> <p> The services can be accessed using the following protocols with their respective bound ports:</p><ul>\n"
 	for protocol, port := range sys.Husk.ProtoPort {
-		protoDoor := "<li> Protocol <b>" + protocol + "</b> using port <em>" + strconv.Itoa(port) + "</em></li>"
-		w.Write([]byte(protoDoor))
+		text += "<li> Protocol <b>" + protocol + "</b> using port <em>" + strconv.Itoa(port) + "</em></li>\n"
 	}
 
-	text = "</ul> <p> of the device whose IP addresses are (upon startup):</p><ul>"
-	w.Write([]byte(text))
+	text += "</ul> <p> of the device whose IP addresses are (upon startup):</p><ul>\n"
 	for _, IPAddre := range sys.Host.IPAddresses {
-		hostaddresses := "<li> " + IPAddre + "</em></li>"
-		w.Write([]byte(hostaddresses))
+		text += "<li> " + IPAddre + "</em></li>\n"
 	}
 
-	text = "</ul></body></html>"
-	w.Write([]byte(text))
+	text += "</ul></body></html>"
+	_, err := w.Write([]byte(text))
+	if err != nil {
+		log.Printf("Error while writing to response body for SysHateoas: %v", err)
+	}
 }
 
 // ResHateoas provides information about the unit asset(s) and each service and is accessed via the system's web server
 func ResHateoas(w http.ResponseWriter, req *http.Request, ua components.UnitAsset, sys components.System) {
-	text := "<!DOCTYPE html><html></head><body>"
-	w.Write([]byte(text))
-
-	text = "<h1>Unit Asset Description</h1>"
-	w.Write([]byte(text))
+	text := "<!DOCTYPE html><html></head><body>\n"
+	text += "<h1>Unit Asset Description</h1>\n"
 
 	uaName := ua.GetName()
 	metaservice := ""
 	for key, values := range ua.GetDetails() {
 		metaservice += key + ": " + fmt.Sprintf("%v", values) + " "
 	}
-	text = "The resource <b>" + uaName + "</b> belongs to system <b>" + sys.Name + "</b> and has the details " + metaservice + " with the following services:" + "<ul>"
-	w.Write([]byte(text))
+	text += "The resource <b>" + uaName + "</b> belongs to system <b>" + sys.Name + "</b> and has the details " + metaservice + " with the following services:" + "<ul>\n"
+
 	services := ua.GetServices()
 	for _, service := range services {
 		metaservice := ""
 		for key, values := range service.Details {
 			metaservice += key + ": " + fmt.Sprintf("%v", values) + " "
 		}
-		serviceURI := "<li><a href=\"http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(sys.Husk.ProtoPort["http"]) + "/" + sys.Name + "/" + uaName + "/" + service.SubPath + "/doc\">" + service.Definition + "</a> with details: " + metaservice + "</li>"
-		w.Write([]byte(serviceURI))
+		text += "<li><a href=\"http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(sys.Husk.ProtoPort["http"]) + "/" + sys.Name + "/" + uaName + "/" + service.SubPath + "/doc\">" + service.Definition + "</a> with details: " + metaservice + "</li>\n"
 	}
 
-	text = "</ul></body></html>"
-	w.Write([]byte(text))
+	text += "</ul></body></html>"
+	_, err := w.Write([]byte(text))
+	if err != nil {
+		log.Printf("Error while writing response body for ResHateoas: %v", err)
+	}
 }
 
 // ServiceHateoas provides information about the service and is accessed via the system's web server
 func ServiceHateoas(w http.ResponseWriter, req *http.Request, ser components.Service, sys components.System) {
 	parts := strings.Split(req.URL.Path, "/")
 	uaName := parts[2]
-	text := "<!DOCTYPE html><html></head><body>"
-	w.Write([]byte(text))
-
-	text = "<h1>Service Description</h1>"
-	w.Write([]byte(text))
+	text := "<!DOCTYPE html><html></head><body>\n"
+	text += "<h1>Service Description</h1>\n"
 
 	metaservice := ""
 	for key, values := range ser.Details {
 		metaservice += key + ": " + fmt.Sprintf("%v", values) + " "
 	}
-	text = "The service <b><a href=\"http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(sys.Husk.ProtoPort["http"]) + "/" + sys.Name + "/" + uaName + "/" + ser.SubPath + "\">" + ser.Definition + "</a> </b> " + ser.Description + " and has the details " + metaservice
-	w.Write([]byte(text))
+	text += "The service <b><a href=\"http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(sys.Husk.ProtoPort["http"]) + "/" + sys.Name + "/" + uaName + "/" + ser.SubPath + "\">" + ser.Definition + "</a> </b> " + ser.Description + " and has the details " + metaservice
+	_, err := w.Write([]byte(text))
+	if err != nil {
+		log.Printf("Error while writing response body for ServiceHateoas: %v", err)
+	}
 }
 
 // // getFirstAsset returns the first key-value pair in the Assets map
diff --git a/usecases/provision.go b/usecases/provision.go
index 4f86d19..eba2f37 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -53,7 +53,11 @@ func HTTPProcessGetRequest(w http.ResponseWriter, r *http.Request, f forms.Form)
 
 	w.Header().Set("Content-Type", bestContentType)
 	w.WriteHeader(http.StatusOK)
-	w.Write(responseData)
+	_, err = w.Write(responseData)
+	if err != nil {
+		// TODO: More might need to happen here?
+		log.Printf("Error while writing response: %v", err)
+	}
 }
 
 // HTTPProcessSetRequest processes a SET request
@@ -108,7 +112,11 @@ func getBestContentType(acceptHeader string) string {
 
 		// Check for q-value in the MIME type
 		if len(parts) > 1 && strings.HasPrefix(parts[1], "q=") {
-			fmt.Sscanf(parts[1], "q=%f", &qValue)
+			_, err := fmt.Sscanf(parts[1], "q=%f", &qValue)
+			if err != nil {
+				// TODO: More might need to happen here?
+				log.Printf("Error while scanning parts of mimeType: %v", err)
+			}
 		}
 
 		// Update the best content type if this one has a higher q-value
diff --git a/usecases/serversNhandlers.go b/usecases/serversNhandlers.go
index cba86df..a6bbb5f 100644
--- a/usecases/serversNhandlers.go
+++ b/usecases/serversNhandlers.go
@@ -73,13 +73,16 @@ func SetoutServers(sys *components.System) (err error) {
 			Certificates: []tls.Certificate{cert},
 			ClientAuth:   tls.RequireAndVerifyClientCert,
 			ClientCAs:    caCertPool,
+			MinVersion:   tls.VersionTLS12,
 		}
 
 		// Create a HTTPS server with the TLS config
 		httpsServer := &http.Server{
-			Addr:      ":" + strconv.Itoa(httpsPort),
-			TLSConfig: tlsConfig,
-			Handler:   nil,
+			Addr:         ":" + strconv.Itoa(httpsPort),
+			ReadTimeout:  30 * time.Second,
+			WriteTimeout: 60 * time.Second,
+			TLSConfig:    tlsConfig,
+			Handler:      nil,
 		}
 
 		// Initiate graceful shutdown on signal reception
@@ -87,7 +90,10 @@ func SetoutServers(sys *components.System) (err error) {
 			<-sys.Ctx.Done()
 			time.Sleep(1 * time.Second) // this line is for the leading service registrar to deregister its own services
 			fmt.Printf("Initiating graceful shutdown of the HTTPS server.\n")
-			httpsServer.Shutdown(sys.Ctx)
+			err = httpsServer.Shutdown(sys.Ctx)
+			if err != nil {
+				log.Printf("Error occured during shutdown: %v", err)
+			}
 		}()
 
 		// Inform the user how to access the system's web server (black box documentation)
@@ -107,8 +113,10 @@ func SetoutServers(sys *components.System) (err error) {
 	if httpPort != 0 {
 		// Create a HTTP server
 		httpServer := &http.Server{
-			Addr:    ":" + strconv.Itoa(httpPort),
-			Handler: nil,
+			Addr:         ":" + strconv.Itoa(httpPort),
+			ReadTimeout:  30 * time.Second,
+			WriteTimeout: 60 * time.Second,
+			Handler:      nil,
 		}
 
 		// Initiate graceful shutdown on signal reception
@@ -116,7 +124,10 @@ func SetoutServers(sys *components.System) (err error) {
 			<-sys.Ctx.Done()
 			time.Sleep(1 * time.Second) // this line is for the leading service registrar to deregister its own services
 			fmt.Printf("Initiating graceful shutdown of the HTTP server.\n")
-			httpServer.Shutdown(sys.Ctx)
+			err = httpServer.Shutdown(sys.Ctx)
+			if err != nil {
+				log.Printf("Error occured during shutdown: %v", err)
+			}
 		}()
 
 		// Inform the user how to access the system's web server (black box documentation)

From 18b5e072f24003dd1a45efefe1ec9973a5d3ceeb Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Thu, 5 Jun 2025 16:44:11 +0200
Subject: [PATCH 004/186] Added error handling for Close() and Write() function
 calls in certificateForms, kgraphing and registration.

---
 forms/certificateForms.go |  5 ++++-
 usecases/kgraphing.go     |  5 ++++-
 usecases/registration.go  | 11 ++++++++---
 3 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/forms/certificateForms.go b/forms/certificateForms.go
index db02549..42d6841 100644
--- a/forms/certificateForms.go
+++ b/forms/certificateForms.go
@@ -51,5 +51,8 @@ func Certificate(w http.ResponseWriter, req *http.Request, sys components.System
 
 	// Set the content type to text/plain
 	w.Header().Set("Content-Type", "text/plain")
-	w.Write([]byte(cert))
+	_, err := w.Write([]byte(cert))
+	if err != nil {
+		log.Println("Error writing the certificate: ", err)
+	}
 }
diff --git a/usecases/kgraphing.go b/usecases/kgraphing.go
index 8bb42f6..c22d851 100644
--- a/usecases/kgraphing.go
+++ b/usecases/kgraphing.go
@@ -45,7 +45,10 @@ func KGraphing(w http.ResponseWriter, req *http.Request, sys *components.System)
 	rdf += modelUAsset(sys)
 
 	w.Header().Set("Content-Type", "text/turtle")
-	w.Write([]byte(rdf))
+	_, err := w.Write([]byte(rdf))
+	if err != nil {
+		fmt.Println("Failed to write KGraphing information: ", err)
+	}
 }
 
 func prefixes() (description string) {
diff --git a/usecases/registration.go b/usecases/registration.go
index 78b7a05..6cdb2ae 100755
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -59,12 +59,15 @@ func RegisterServices(sys *components.System) {
 
 				// Read from resp.Body and then close it directly after
 				bodyBytes, err := io.ReadAll(resp.Body)
-				resp.Body.Close() // Close the body directly after reading from it
+				errClose := resp.Body.Close() // Close the body directly after reading from it
 				if err != nil {
 					log.Println("\rError reading response from leading registrar:", err)
 					leadingRegistrar = nil
 					continue // Skip to the next iteration of the loop
 				}
+				if errClose != nil {
+					log.Println("Error closing the leading registrar response body:", errClose)
+				}
 
 				if !strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
 					leadingRegistrar = nil
@@ -82,12 +85,14 @@ func RegisterServices(sys *components.System) {
 
 						// Read from resp.Body and then close it directly after
 						bodyBytes, err := io.ReadAll(resp.Body)
-						resp.Body.Close() // Close the body directly after reading from it
+						errClose := resp.Body.Close() // Close the body directly after reading from it
 						if err != nil {
 							fmt.Println("Error reading service registrar response body:", err)
 							continue // Skip to the next iteration of the loop
 						}
-
+						if errClose != nil {
+							fmt.Println("Error closing service registrar response body:", errClose)
+						}
 						if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
 							leadingRegistrar = core
 							fmt.Printf("\nlead registrar found at: %s\n", leadingRegistrar.Url)

From c71e7a337e6a0b6e635afc7de8347b64536df33a Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 5 Jun 2025 17:06:04 +0200
Subject: [PATCH 005/186] Removed pointer part of linter, it's a later problem

---
 Makefile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index d7ce277..ece9093 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,8 @@ lint:
 	test -z $$(gofmt -l .) || (echo "Code isn't gofmt'ed!" && exit 1)
 	go vet $$(go list ./... | grep -v /tmp)
 	gosec -quiet -fmt=golint -exclude-dir="tmp" ./...
-	pointerinterface ./...
+
+# pointerinterface ./...
 
 # Runs spellchecker on the code and comments
 # This requires this tool to be installed from https://github.com/crate-ci/typos?tab=readme-ov-file

From 90bdc4923b97aac74baf1be632af9659dd30c262 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 9 Jun 2025 09:23:50 +0200
Subject: [PATCH 006/186] Fixed test name and test function name for workflow

---
 usecases/sample_test.go | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 usecases/sample_test.go

diff --git a/usecases/sample_test.go b/usecases/sample_test.go
new file mode 100644
index 0000000..cd44f08
--- /dev/null
+++ b/usecases/sample_test.go
@@ -0,0 +1,33 @@
+package usecases
+
+import (
+	"net/http"
+	"testing"
+)
+
+// mockTransport is used for replacing the default network Transport (used by
+// http.DefaultClient) and it will intercept network requests.
+type mockTransport struct {
+	resp *http.Response
+}
+
+func newMockTransport(resp *http.Response) mockTransport {
+	t := mockTransport{
+		resp: resp,
+	}
+	// Hijack the default http client so no actual http requests are sent over the network
+	http.DefaultClient.Transport = t
+	return t
+}
+
+// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
+// It prevents the request from being sent over the network and count how many times
+// a domain was requested.
+func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	t.resp.Request = req
+	return t.resp, nil
+}
+
+func TestSample(t *testing.T) {
+	return
+}

From 5ba705f8497af82af8da5f450e9bd0f42c630b57 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 9 Jun 2025 09:30:44 +0200
Subject: [PATCH 007/186] Removed old sample test file

---
 usecases/test_sample.go | 33 ---------------------------------
 1 file changed, 33 deletions(-)
 delete mode 100644 usecases/test_sample.go

diff --git a/usecases/test_sample.go b/usecases/test_sample.go
deleted file mode 100644
index 14ff4fb..0000000
--- a/usecases/test_sample.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package usecases
-
-import (
-	"net/http"
-	"testing"
-)
-
-// mockTransport is used for replacing the default network Transport (used by
-// http.DefaultClient) and it will intercept network requests.
-type mockTransport struct {
-	resp *http.Response
-}
-
-func newMockTransport(resp *http.Response) mockTransport {
-	t := mockTransport{
-		resp: resp,
-	}
-	// Hijack the default http client so no actual http requests are sent over the network
-	http.DefaultClient.Transport = t
-	return t
-}
-
-// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
-// It prevents the request from being sent over the network and count how many times
-// a domain was requested.
-func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-	t.resp.Request = req
-	return t.resp, nil
-}
-
-func test_sample(t *testing.T) {
-	return
-}

From 7815ac9a6ecb6b1330ad4b5f4b328b66ffce17f4 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 9 Jun 2025 09:44:29 +0200
Subject: [PATCH 008/186] Fixed some spellchecks

---
 components/service.go                           | 2 +-
 forms/{formsDefiniton.go => formsDefinition.go} | 0
 usecases/cost.go                                | 2 +-
 usecases/provision.go                           | 2 +-
 usecases/serviceDiscovery.go                    | 4 ++--
 5 files changed, 5 insertions(+), 5 deletions(-)
 rename forms/{formsDefiniton.go => formsDefinition.go} (100%)

diff --git a/components/service.go b/components/service.go
index ff8a14c..05ac67d 100644
--- a/components/service.go
+++ b/components/service.go
@@ -37,7 +37,7 @@ type Service struct {
 	CUnit         string              `json:"costUnit"`           // cost unit
 }
 
-// type Services is a collection of service stucts
+// type Services is a collection of service structs
 type Services map[string]*Service
 
 // Merge method is used in the configuration use case to prevent the subpath or description to be changed or "configured"
diff --git a/forms/formsDefiniton.go b/forms/formsDefinition.go
similarity index 100%
rename from forms/formsDefiniton.go
rename to forms/formsDefinition.go
diff --git a/usecases/cost.go b/usecases/cost.go
index 888e8d5..e4eed2f 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -47,7 +47,7 @@ func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		log.Printf("Error unmarshaling JSON data: %v", err)
+		log.Printf("Error unmarshalling JSON data: %v", err)
 		return
 	}
 	formVersion, ok := jsonData["version"].(string)
diff --git a/usecases/provision.go b/usecases/provision.go
index eba2f37..83bae9b 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -71,7 +71,7 @@ func HTTPProcessSetRequest(w http.ResponseWriter, req *http.Request) (f forms.Si
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		log.Printf("Error unmarshaling JSON data: %v", err)
+		log.Printf("Error unmarshalling JSON data: %v", err)
 		return
 	}
 	formVersion, ok := jsonData["version"].(string)
diff --git a/usecases/serviceDiscovery.go b/usecases/serviceDiscovery.go
index 6ab3921..2e5c389 100644
--- a/usecases/serviceDiscovery.go
+++ b/usecases/serviceDiscovery.go
@@ -57,7 +57,7 @@ func ExtractQuestForm(bodyBytes []byte) (rec forms.ServiceQuest_v1, err error) {
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		log.Printf("Error unmarshaling JSON data: %v", err)
+		log.Printf("Error unmarshalling JSON data: %v", err)
 		return
 	}
 	formVersion, ok := jsonData["version"].(string)
@@ -229,7 +229,7 @@ func ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err err
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		log.Printf("Error unmarshaling JSON data: %v", err)
+		log.Printf("Error unmarshalling JSON data: %v", err)
 		return
 	}
 	formVersion, ok := jsonData["version"].(string)

From 10562ee64369735a9fa04c0abb72e4f76ae08aab Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 9 Jun 2025 09:59:36 +0200
Subject: [PATCH 009/186] Fixed spellchecking errors, ser -> serv, occured ->
 occurred

---
 usecases/configuration.go    |  8 +++----
 usecases/docs.go             |  6 ++---
 usecases/packing.go          |  8 +++----
 usecases/registration.go     | 44 ++++++++++++++++++------------------
 usecases/serversNhandlers.go |  4 ++--
 5 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index 4862200..ad7e846 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -30,7 +30,7 @@ import (
 	"github.com/sdoque/mbaigo/components"
 )
 
-// templateOut is the stuct used to prepare the systemconfig.json file
+// templateOut is the struct used to prepare the systemconfig.json file
 type templateOut struct {
 	CName      string                  `json:"systemname"`
 	UAsset     []components.UnitAsset  `json:"unit_assets"`
@@ -40,7 +40,7 @@ type templateOut struct {
 	CCoreS     []components.CoreSystem `json:"coreSystems"`
 }
 
-// configFileIn is used to extact out the information of the systemconfig.json file
+// configFileIn is used to extract out the information of the systemconfig.json file
 // Since it does not know about the details of the Thing, it does not unmarsahll this
 // information
 type configFileIn struct {
@@ -74,7 +74,7 @@ func Configure(sys *components.System) ([]json.RawMessage, []components.Service,
 	defaultConfig.PKIdetails.Organization = []string{"Luleaa University of Technology"}
 	defaultConfig.PKIdetails.OrganizationalUnit = []string{"CPS"}
 
-	serReg := components.CoreSystem{
+	servReg := components.CoreSystem{
 		Name:        "serviceregistrar",
 		Url:         "http://localhost:20102/serviceregistrar/registry",
 		Certificate: ".X509pubKey",
@@ -89,7 +89,7 @@ func Configure(sys *components.System) ([]json.RawMessage, []components.Service,
 		Url:         "http://localhost:20100/ca/certification",
 		Certificate: ".X509pubKey",
 	}
-	coreSystems := []components.CoreSystem{serReg, orches, ca}
+	coreSystems := []components.CoreSystem{servReg, orches, ca}
 	defaultConfig.CCoreS = coreSystems
 
 	// open the configuration file or create one with the default content prepared above
diff --git a/usecases/docs.go b/usecases/docs.go
index f2644a0..8212482 100644
--- a/usecases/docs.go
+++ b/usecases/docs.go
@@ -111,17 +111,17 @@ func ResHateoas(w http.ResponseWriter, req *http.Request, ua components.UnitAsse
 }
 
 // ServiceHateoas provides information about the service and is accessed via the system's web server
-func ServiceHateoas(w http.ResponseWriter, req *http.Request, ser components.Service, sys components.System) {
+func ServiceHateoas(w http.ResponseWriter, req *http.Request, serv components.Service, sys components.System) {
 	parts := strings.Split(req.URL.Path, "/")
 	uaName := parts[2]
 	text := "<!DOCTYPE html><html></head><body>\n"
 	text += "<h1>Service Description</h1>\n"
 
 	metaservice := ""
-	for key, values := range ser.Details {
+	for key, values := range serv.Details {
 		metaservice += key + ": " + fmt.Sprintf("%v", values) + " "
 	}
-	text += "The service <b><a href=\"http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(sys.Husk.ProtoPort["http"]) + "/" + sys.Name + "/" + uaName + "/" + ser.SubPath + "\">" + ser.Definition + "</a> </b> " + ser.Description + " and has the details " + metaservice
+	text += "The service <b><a href=\"http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(sys.Husk.ProtoPort["http"]) + "/" + sys.Name + "/" + uaName + "/" + serv.SubPath + "\">" + serv.Definition + "</a> </b> " + serv.Description + " and has the details " + metaservice
 	_, err := w.Write([]byte(text))
 	if err != nil {
 		log.Printf("Error while writing response body for ServiceHateoas: %v", err)
diff --git a/usecases/packing.go b/usecases/packing.go
index 6990274..6f1252f 100644
--- a/usecases/packing.go
+++ b/usecases/packing.go
@@ -78,12 +78,12 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, &rawData); err != nil {
-			log.Printf("Error unmarshaling JSON: %v", err)
+			log.Printf("Error unmarshalling JSON: %v", err)
 			return nil, err
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, &rawData); err != nil {
-			log.Printf("Error unmarshaling XML: %v", err)
+			log.Printf("Error unmarshalling XML: %v", err)
 			return nil, err
 		}
 	default:
@@ -109,12 +109,12 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, formInstance); err != nil {
-			log.Printf("Error unmarshaling JSON into form: %v", err)
+			log.Printf("Error unmarshalling JSON into form: %v", err)
 			return nil, err
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, formInstance); err != nil {
-			log.Printf("Error unmarshaling XML into form: %v", err)
+			log.Printf("Error unmarshalling XML into form: %v", err)
 			return nil, err
 		}
 	}
diff --git a/usecases/registration.go b/usecases/registration.go
index 6cdb2ae..86d8423 100755
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -135,11 +135,11 @@ func RegisterServices(sys *components.System) {
 }
 
 // registerService makes a POST or PUT request to register or register individual services
-func registerService(sys *components.System, ua *components.UnitAsset, ser *components.Service, registrar *components.CoreSystem) (delay time.Duration) {
+func registerService(sys *components.System, ua *components.UnitAsset, serv *components.Service, registrar *components.CoreSystem) (delay time.Duration) {
 
 	delay = 15 * time.Second
 	// Prepare request
-	reqPayload, err := serviceRegistrationForm(sys, ua, ser, "ServiceRecord_v1")
+	reqPayload, err := serviceRegistrationForm(sys, ua, serv, "ServiceRecord_v1")
 	if err != nil {
 		log.Println("Registration marshall error, ", err)
 		return
@@ -147,16 +147,16 @@ func registerService(sys *components.System, ua *components.UnitAsset, ser *comp
 	registrationurl := registrar.Url + "/register"
 
 	var req *http.Request // Declare req outside the blocks
-	if ser.ID == 0 {
+	if serv.ID == 0 {
 		req, err = http.NewRequest("POST", registrationurl, bytes.NewBuffer(reqPayload))
 		if err != nil {
-			log.Printf("unable to register service %s with lead registrar\n", ser.Definition)
+			log.Printf("unable to register service %s with lead registrar\n", serv.Definition)
 			return
 		}
 	} else {
 		req, err = http.NewRequest("PUT", registrationurl, bytes.NewBuffer(reqPayload))
 		if err != nil {
-			log.Printf("unable to confirm the %s service with lead registar", ser.Definition)
+			log.Printf("unable to confirm the %s service with lead registar", serv.Definition)
 			return
 		}
 	}
@@ -169,13 +169,13 @@ func registerService(sys *components.System, ua *components.UnitAsset, ser *comp
 			if err.Timeout() {
 				log.Printf("registry timeout with lead registrar %s\n", registrationurl)
 			} else {
-				log.Printf("unable to (re-)register service %s with lead registrar\n", ser.Definition)
+				log.Printf("unable to (re-)register service %s with lead registrar\n", serv.Definition)
 			}
 		default:
 			log.Printf("registration request error with %s, and error %s\n", registrationurl, err)
 		}
 		registrar = nil
-		ser.ID = 0 // if re-registration failed, a complete new one should be made (POST)
+		serv.ID = 0 // if re-registration failed, a complete new one should be made (POST)
 		return
 	}
 
@@ -202,9 +202,9 @@ func registerService(sys *components.System, ua *components.UnitAsset, ser *comp
 			return
 		}
 
-		ser.ID = rr.Id
-		ser.RegTimestamp = rr.Created
-		ser.RegExpiration = rr.EndOfValidity
+		serv.ID = rr.Id
+		serv.RegTimestamp = rr.Created
+		serv.RegExpiration = rr.EndOfValidity
 		parsedTime, err := time.Parse(time.RFC3339, rr.EndOfValidity)
 		if err != nil {
 			log.Printf("Error parsing input: %s", err)
@@ -217,12 +217,12 @@ func registerService(sys *components.System, ua *components.UnitAsset, ser *comp
 }
 
 // deregisterService deletes a service from the database based on its service id
-func deregisterService(registrar *components.CoreSystem, ser *components.Service) {
+func deregisterService(registrar *components.CoreSystem, serv *components.Service) {
 	if registrar == nil {
 		return // there is no need to deregister if there is no leading registrar
 	}
 	client := &http.Client{}
-	deRegServURL := registrar.Url + "/unregister/" + strconv.Itoa(ser.ID)
+	deRegServURL := registrar.Url + "/unregister/" + strconv.Itoa(serv.ID)
 	fmt.Printf("Trying to unregiseter %s\n", deRegServURL)
 	req, err := http.NewRequest("DELETE", deRegServURL, nil) // create a new request using http
 	if err != nil {
@@ -235,22 +235,22 @@ func deregisterService(registrar *components.CoreSystem, ser *components.Service
 		return
 	}
 	defer resp.Body.Close()
-	fmt.Printf("service %s deleted from the service registrar with HTTP Response Status: %d, %s\n", ser.Definition, resp.StatusCode, http.StatusText(resp.StatusCode))
+	fmt.Printf("service %s deleted from the service registrar with HTTP Response Status: %d, %s\n", serv.Definition, resp.StatusCode, http.StatusText(resp.StatusCode))
 }
 
 // serviceRegistrationForm returns a json data byte array with the data of the service to be registered
 // in the form of choice [Sending @ Application system]
-func serviceRegistrationForm(sys *components.System, ua *components.UnitAsset, ser *components.Service, version string) (payload []byte, err error) {
+func serviceRegistrationForm(sys *components.System, ua *components.UnitAsset, serv *components.Service, version string) (payload []byte, err error) {
 	var f forms.Form
 	switch version {
 	case "ServiceRecord_v1":
 		resName := (*ua).GetName()
 		var sr forms.ServiceRecord_v1 // declare a new service form
 		sr.NewForm()
-		sr.Id = ser.ID
-		sr.ServiceDefinition = ser.Definition
+		sr.Id = serv.ID
+		sr.ServiceDefinition = serv.Definition
 		sr.SystemName = sys.Name
-		sr.ServiceNode = sys.Host.Name + "_" + sys.Name + "_" + resName + "_" + ser.Definition
+		sr.ServiceNode = sys.Host.Name + "_" + sys.Name + "_" + resName + "_" + serv.Definition
 		sr.IPAddresses = sys.Host.IPAddresses
 		sr.ProtoPort = make(map[string]int) // initialize the map
 		for key, port := range sys.Husk.ProtoPort {
@@ -259,17 +259,17 @@ func serviceRegistrationForm(sys *components.System, ua *components.UnitAsset, s
 			}
 		}
 		sr.Details = deepCopyMap((*ua).GetDetails())
-		for key, valueSlice := range ser.Details {
+		for key, valueSlice := range serv.Details {
 			sr.Details[key] = append(sr.Details[key], valueSlice...)
 		}
-		sr.SubPath = resName + "/" + ser.SubPath
+		sr.SubPath = resName + "/" + serv.SubPath
 
-		if ser.RegPeriod != 0 {
-			sr.RegLife = ser.RegPeriod
+		if serv.RegPeriod != 0 {
+			sr.RegLife = serv.RegPeriod
 		} else {
 			sr.RegLife = 30
 		}
-		sr.Created = ser.RegTimestamp
+		sr.Created = serv.RegTimestamp
 		f = &sr
 	default:
 		err = errors.New("unsupported service registration form version")
diff --git a/usecases/serversNhandlers.go b/usecases/serversNhandlers.go
index a6bbb5f..f5e19bb 100644
--- a/usecases/serversNhandlers.go
+++ b/usecases/serversNhandlers.go
@@ -92,7 +92,7 @@ func SetoutServers(sys *components.System) (err error) {
 			fmt.Printf("Initiating graceful shutdown of the HTTPS server.\n")
 			err = httpsServer.Shutdown(sys.Ctx)
 			if err != nil {
-				log.Printf("Error occured during shutdown: %v", err)
+				log.Printf("Error occurred during shutdown: %v", err)
 			}
 		}()
 
@@ -126,7 +126,7 @@ func SetoutServers(sys *components.System) (err error) {
 			fmt.Printf("Initiating graceful shutdown of the HTTP server.\n")
 			err = httpServer.Shutdown(sys.Ctx)
 			if err != nil {
-				log.Printf("Error occured during shutdown: %v", err)
+				log.Printf("Error occurred during shutdown: %v", err)
 			}
 		}()
 

From 216ef0ee5b62010bb5182a340836c1922dedf348 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 9 Jun 2025 10:01:04 +0200
Subject: [PATCH 010/186] Fixed spellchecking error, relpy -> reply

---
 usecases/registration.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index 86d8423..3c0ebcb 100755
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -192,7 +192,7 @@ func registerService(sys *components.System, ua *components.UnitAsset, serv *com
 		headerContentTtype := resp.Header.Get("Content-Type")
 		rRecord, err := Unpack(bodyBytes, headerContentTtype)
 		if err != nil {
-			log.Printf("error extracting the registration record relpy %v\n", err)
+			log.Printf("error extracting the registration record reply %v\n", err)
 		}
 
 		// Perform a type assertion to convert the returned Form to ServiceRecord_v1

From 6b9903f8978c03c5a85d7f37d734fade3ace424b Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 9 Jun 2025 12:09:34 +0200
Subject: [PATCH 011/186] Added test for ServQuestForms()

---
 usecases/sample_test.go           | 32 +++++++++++++-----------
 usecases/serviceDiscovery_test.go | 41 +++++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 15 deletions(-)
 create mode 100644 usecases/serviceDiscovery_test.go

diff --git a/usecases/sample_test.go b/usecases/sample_test.go
index cd44f08..a117a15 100644
--- a/usecases/sample_test.go
+++ b/usecases/sample_test.go
@@ -1,33 +1,35 @@
 package usecases
 
 import (
-	"net/http"
 	"testing"
 )
 
+/*
 // mockTransport is used for replacing the default network Transport (used by
 // http.DefaultClient) and it will intercept network requests.
-type mockTransport struct {
-	resp *http.Response
-}
 
-func newMockTransport(resp *http.Response) mockTransport {
-	t := mockTransport{
-		resp: resp,
+	type mockTransport struct {
+		resp *http.Response
+	}
+
+	func newMockTransport(resp *http.Response) mockTransport {
+		t := mockTransport{
+			resp: resp,
+		}
+		// Hijack the default http client so no actual http requests are sent over the network
+		http.DefaultClient.Transport = t
+		return t
 	}
-	// Hijack the default http client so no actual http requests are sent over the network
-	http.DefaultClient.Transport = t
-	return t
-}
 
 // RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
 // It prevents the request from being sent over the network and count how many times
 // a domain was requested.
-func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-	t.resp.Request = req
-	return t.resp, nil
-}
 
+	func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+		t.resp.Request = req
+		return t.resp, nil
+	}
+*/
 func TestSample(t *testing.T) {
 	return
 }
diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
new file mode 100644
index 0000000..91a9dee
--- /dev/null
+++ b/usecases/serviceDiscovery_test.go
@@ -0,0 +1,41 @@
+package usecases
+
+import (
+	"net/http"
+	"testing"
+)
+
+// mockTransport is used for replacing the default network Transport (used by
+// http.DefaultClient) and it will intercept network requests.
+type mockTransport struct {
+	resp *http.Response
+}
+
+func newMockTransport(resp *http.Response) mockTransport {
+	t := mockTransport{
+		resp: resp,
+	}
+	// Hijack the default http client so no actual http requests are sent over the network
+	http.DefaultClient.Transport = t
+	return t
+}
+
+// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
+// It prevents the request from being sent over the network and count how many times
+// a domain was requested.
+func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	t.resp.Request = req
+	return t.resp, nil
+}
+
+// Tests the output from ServQuestForms() to ensure expected outcome
+func TestServQuestForms(t *testing.T) {
+	expectedForms := []string{"ServiceQuest_v1", "ServicePoint_v1"}
+	lst := ServQuestForms()
+	// Loop through the forms from ServQuestForms() and compare them to expected forms
+	for i, form := range lst {
+		if form != expectedForms[i] {
+			t.Errorf("Expected %s, got %s", form, expectedForms[i])
+		}
+	}
+}

From 12d1d65277c0a889c977608e5373f58950c6d6a8 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 9 Jun 2025 13:13:40 +0200
Subject: [PATCH 012/186] Added test for FillQuestForm()

---
 usecases/serviceDiscovery_test.go | 55 +++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 91a9dee..c09782d 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -1,8 +1,11 @@
 package usecases
 
 import (
+	"context"
 	"net/http"
 	"testing"
+
+	"github.com/sdoque/mbaigo/components"
 )
 
 // mockTransport is used for replacing the default network Transport (used by
@@ -28,6 +31,30 @@ func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err er
 	return t.resp, nil
 }
 
+type mockUnitAsset struct {
+}
+
+func (mua mockUnitAsset) GetName() string {
+	return "Test UnitAsset"
+}
+
+func (mua mockUnitAsset) GetServices() components.Services {
+	return nil
+}
+func (mua mockUnitAsset) GetCervices() components.Cervices {
+	return nil
+}
+
+func (mua mockUnitAsset) GetDetails() map[string][]string {
+	return map[string][]string{
+		"Details": []string{"test1", "test2"},
+	}
+}
+
+func (mua mockUnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
+	return
+}
+
 // Tests the output from ServQuestForms() to ensure expected outcome
 func TestServQuestForms(t *testing.T) {
 	expectedForms := []string{"ServiceQuest_v1", "ServicePoint_v1"}
@@ -39,3 +66,31 @@ func TestServQuestForms(t *testing.T) {
 		}
 	}
 }
+
+func createTestSystem(ctx context.Context) components.System {
+	// instantiate the System
+	sys := components.NewSystem("testSystem", ctx)
+
+	// Instatiate the Capusle
+	sys.Husk = &components.Husk{
+		Description: "A test system",
+		Details:     map[string][]string{"Developer": {"Test dev"}},
+		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
+		InfoLink:    "https://for.testing.purposes",
+	}
+	return sys
+}
+
+func TestFillQuestForm(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
+	mua := mockUnitAsset{}
+	questForm := FillQuestForm(&testSys, mua, "TestDef", "TestProtocol")
+	// Loop through the details in questForm and mua (mockUnitAsset), error if they're same
+	for i, detail := range questForm.Details["Details"] {
+		if detail != mua.GetDetails()["Details"][i] {
+			t.Errorf("Expected %s, got: %s", mua.GetDetails()["Details"][i], detail)
+		}
+	}
+}

From d1563c3238accb12f9b8f2fff5feb76fdf605786 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 9 Jun 2025 14:27:57 +0200
Subject: [PATCH 013/186] Added test for ExtractQuestForm()

---
 usecases/serviceDiscovery_test.go | 71 +++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index c09782d..22767c3 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -2,6 +2,8 @@ package usecases
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 	"net/http"
 	"testing"
 
@@ -94,3 +96,72 @@ func TestFillQuestForm(t *testing.T) {
 		}
 	}
 }
+
+type testBodyHasProtocol struct {
+	Version  string `json:"version"`
+	Protocol int    `json:"protocol"`
+}
+
+type testBodyHasVersion struct {
+	Version string `json:"version"`
+}
+type testBodyNoVersion struct{}
+
+// Create a error reader to break json.unmarshal
+type errReader int
+
+var errBodyRead error = fmt.Errorf("bad body read")
+
+func (errReader) Read(p []byte) (n int, err error) {
+	return 0, errBodyRead
+}
+func (errReader) Close() error {
+	return nil
+}
+
+func TestExtractQuestForm(t *testing.T) {
+	body := testBodyHasVersion{
+		Version: "ServiceQuest_v1",
+	}
+	data, _ := json.Marshal(body)
+
+	// Everything passes, best outcome
+	rec, _ := ExtractQuestForm(data)
+	if rec.Version != body.Version {
+		t.Errorf("Expected version: %s, got: %s", rec.Version, body.Version)
+	}
+
+	// Can't unmarshal data
+	data, _ = json.Marshal(errReader(0))
+	rec, err := ExtractQuestForm(data)
+	if err == nil {
+		t.Errorf("Expected error during unmarshal")
+	}
+	// Missing version
+	noVersionBody := testBodyNoVersion{}
+	data, _ = json.Marshal(noVersionBody)
+	rec, err = ExtractQuestForm(data)
+	if rec.Version != "" {
+		t.Errorf("Expected no version, got %s", rec.Version)
+	}
+	// Error while writing to correct form
+	protocolBody := testBodyHasProtocol{
+		Version:  "ServiceQuest_v1",
+		Protocol: 123,
+	}
+	data, _ = json.Marshal(protocolBody)
+	rec, err = ExtractQuestForm(data)
+	if err == nil {
+		t.Errorf("Expected Error during unmarshal in switch case")
+	}
+
+	// Switch case: Unsupported service registration form
+	body = testBodyHasVersion{
+		Version: "",
+	}
+	data, _ = json.Marshal(body)
+	rec, err = ExtractQuestForm(data)
+	if err == nil {
+		t.Errorf("Expected error in switch case (Unsupported form version)")
+	}
+}

From b287027c90eec57299eb57a60622d9b8596f0dc5 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 9 Jun 2025 17:23:33 +0200
Subject: [PATCH 014/186] Tests for Search4Service(), work in progress

---
 usecases/serviceDiscovery.go      |  4 +--
 usecases/serviceDiscovery_test.go | 54 ++++++++++++++++++++++++++++++-
 2 files changed, 55 insertions(+), 3 deletions(-)

diff --git a/usecases/serviceDiscovery.go b/usecases/serviceDiscovery.go
index 2e5c389..135cc02 100644
--- a/usecases/serviceDiscovery.go
+++ b/usecases/serviceDiscovery.go
@@ -110,8 +110,8 @@ func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocat
 	req = req.WithContext(ctx)                         // associate the cancellable context with the request
 
 	// Send the request /////////////////////////////////
-	client := &http.Client{}
-	resp, err := client.Do(req)
+	//client := &http.Client{}
+	resp, err := http.DefaultClient.Do(req) // changed to DefaultClient to simplify testing
 	if err != nil {
 		return servLocation, err
 	}
diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 22767c3..48291fe 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -4,10 +4,13 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
+	"strings"
 	"testing"
 
 	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/forms"
 )
 
 // mockTransport is used for replacing the default network Transport (used by
@@ -73,13 +76,20 @@ func createTestSystem(ctx context.Context) components.System {
 	// instantiate the System
 	sys := components.NewSystem("testSystem", ctx)
 
-	// Instatiate the Capusle
+	// Instantiate the Capsule
 	sys.Husk = &components.Husk{
 		Description: "A test system",
 		Details:     map[string][]string{"Developer": {"Test dev"}},
 		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
 		InfoLink:    "https://for.testing.purposes",
 	}
+	orchestrator := &components.CoreSystem{
+		Name: "orchestrator",
+		Url:  "https://orchestator",
+	}
+	sys.CoreS = []*components.CoreSystem{
+		orchestrator,
+	}
 	return sys
 }
 
@@ -165,3 +175,45 @@ func TestExtractQuestForm(t *testing.T) {
 		t.Errorf("Expected error in switch case (Unsupported form version)")
 	}
 }
+
+func createTestForm(f forms.ServiceQuest_v1) {
+	f.NewForm()
+	f.SysId = 999
+	f.RequesterName = "Requester"
+	f.ServiceDefinition = "TestService"
+	f.Protocol = ""
+	f.Details = map[string][]string{
+		"Details": {"detail_1", "detail_2"},
+	}
+	f.Version = "SignalA_v1a"
+}
+
+func TestSearch4Service(t *testing.T) {
+	// Best case, everything pass
+	var f forms.ServicePoint_v1
+	f.NewForm()
+	f.Version = "ServicePoint_v1"
+	f.ServLocation = "TestService"
+	// Create mock response from orchestrator
+	fakeBody, err := json.Marshal(f)
+	if err != nil {
+		t.Errorf("Fail Marshal at start of test")
+	}
+	resp := &http.Response{
+		Status:     "200 OK",
+		StatusCode: 200,
+		Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+	}
+	newMockTransport(resp)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
+	var qForm forms.ServiceQuest_v1
+	serviceForm, err := Search4Service(qForm, &testSys)
+	if err != nil {
+		t.Errorf("Expected no errors, got: %v", err)
+	}
+	if serviceForm.ServLocation != f.ServLocation {
+		t.Errorf("Expected %s, got: %s", f.ServLocation, serviceForm.ServLocation)
+	}
+}

From bb51a3dbca8d86066623e8238d5d2227036af8b7 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 9 Jun 2025 22:12:59 +0200
Subject: [PATCH 015/186] Removed sample_test.go, made test for the beginning
 part of registerServices.

---
 usecases/registration.go      |  73 ++++++++++++++
 usecases/registration_test.go | 174 ++++++++++++++++++++++++++++++++++
 usecases/sample_test.go       |  33 -------
 3 files changed, 247 insertions(+), 33 deletions(-)
 create mode 100644 usecases/registration_test.go
 delete mode 100644 usecases/sample_test.go

diff --git a/usecases/registration.go b/usecases/registration.go
index 3c0ebcb..0dba5ce 100755
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -134,6 +134,79 @@ func RegisterServices(sys *components.System) {
 	}
 }
 
+func DiscoverLeadingRegistrar(sys *components.System, url string, leadingRegistrarTest bool) (test bool) {
+	var leadingRegistrar *components.CoreSystem
+	if leadingRegistrarTest == true {
+		leadingRegistrar = &components.CoreSystem{
+			Name:        "leadingregistrar",
+			Url:         "https://leadingregistrar",
+			Certificate: "",
+		}
+	}
+	// Create a buffered channel for the pointer to the leading service registrar
+	registrarStream := make(chan *components.CoreSystem, 1)
+	defer close(registrarStream)
+	ticker := time.NewTicker(5 * time.Second)
+	defer ticker.Stop()
+	if leadingRegistrar != nil {
+		//resp, err := http.Get(leadingRegistrar.Url + "/status")
+		resp, err := http.Get(url) // #nosec G107
+		if err != nil {
+			log.Println("lost leading registrar status:", err)
+			leadingRegistrar = nil
+			return false
+		}
+
+		// Read from resp.Body and then close it directly after
+		bodyBytes, err := io.ReadAll(resp.Body)
+		errClose := resp.Body.Close() // Close the body directly after reading from it
+		if err != nil {
+			log.Println("\rError reading response from leading registrar:", err)
+			leadingRegistrar = nil
+			return false
+		}
+		if errClose != nil {
+			log.Println("Error closing the leading registrar response body:", errClose)
+		}
+
+		if !strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
+			leadingRegistrar = nil
+			log.Println("lost previous leading registrar")
+			return false
+		}
+		return true
+	} else {
+		for _, cSys := range sys.CoreS {
+			core := cSys
+			if core.Name == "serviceregistrar" {
+				//resp, err := http.Get(core.Url + "/status")
+				resp, err := http.Get(url) // #nosec G107
+				if err != nil {
+					fmt.Println("error checking service registrar status:", err)
+					continue // Skip to the next iteration of the loop
+				}
+
+				// Read from resp.Body and then close it directly after
+				bodyBytes, err := io.ReadAll(resp.Body)
+				errClose := resp.Body.Close() // Close the body directly after reading from it
+				if err != nil {
+					fmt.Println("Error reading service registrar response body:", err)
+					continue // Skip to the next iteration of the loop
+				}
+				if errClose != nil {
+					fmt.Println("Error closing service registrar response body:", errClose)
+				}
+				if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
+					leadingRegistrar = core
+					fmt.Printf("\nlead registrar found at: %s\n", leadingRegistrar.Url)
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
 // registerService makes a POST or PUT request to register or register individual services
 func registerService(sys *components.System, ua *components.UnitAsset, serv *components.Service, registrar *components.CoreSystem) (delay time.Duration) {
 
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
new file mode 100644
index 0000000..83b80a4
--- /dev/null
+++ b/usecases/registration_test.go
@@ -0,0 +1,174 @@
+package usecases
+
+import (
+	//"bytes"
+	"context"
+	//"encoding/json"
+	//"errors"
+	//"fmt"
+	//"io"
+	//"log"
+	//"net"
+	"net/http"
+	"net/http/httptest"
+
+	//"strconv"
+	//"strings"
+	"testing"
+	//"time"
+
+	"github.com/sdoque/mbaigo/components"
+	//"github.com/sdoque/mbaigo/forms"
+)
+
+type mockTransport struct {
+	resp *http.Response
+}
+
+func newMockTransport(resp *http.Response) mockTransport {
+	t := mockTransport{
+		resp: resp,
+	}
+	http.DefaultClient.Transport = t
+	return t
+}
+
+func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	t.resp.Request = req
+	return t.resp, nil
+}
+
+type mockUnitAsset struct {
+}
+
+func (mua mockUnitAsset) GetName() string {
+	return "Test UnitAsset"
+}
+
+func (mua mockUnitAsset) GetServices() components.Services {
+	return nil
+}
+
+func (mua mockUnitAsset) GetCervices() components.Cervices {
+	return nil
+}
+
+func (mua mockUnitAsset) GetDetails() map[string][]string {
+	return map[string][]string{
+		"Details": []string{"test1", "test2"},
+	}
+}
+
+func (mua mockUnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
+	return
+}
+
+func createTestSystem(ctx context.Context) components.System {
+	sys := components.NewSystem("testSystem", ctx)
+
+	sys.Husk = &components.Husk{
+		Description: "A test system",
+		Details:     map[string][]string{"Developer": {"Test dev"}},
+		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
+		InfoLink:    "https://for.testing.purposes",
+	}
+
+	orchestrator := &components.CoreSystem{
+		Name:        "orchestrator",
+		Url:         "https://orchestrator",
+		Certificate: "",
+	}
+	leadingRegistrar := &components.CoreSystem{
+		Name:        "serviceregistrar",
+		Url:         "https://leadingregistrar",
+		Certificate: "",
+	}
+	test := &components.CoreSystem{
+		Name:        "test",
+		Url:         "https://test",
+		Certificate: "",
+	}
+	sys.CoreS = []*components.CoreSystem{
+		orchestrator,
+		leadingRegistrar,
+		test,
+	}
+	return sys
+}
+
+func TestDiscoverLeadingRegistrar(t *testing.T) {
+	statusCode := http.StatusOK
+	responseBody := "lead Service Registrar since"
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(statusCode)
+		w.Write([]byte(responseBody))
+	}))
+	defer ts.Close()
+	testURL := ts.URL
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
+
+	result := DiscoverLeadingRegistrar(&testSys, testURL, false)
+	if result != true {
+		t.Errorf("Expected %t, got: %t", true, result)
+	}
+
+	/*
+		statusCode = http.StatusBadRequest
+		responseBody = "lead Service Registrar since"
+		result = DiscoverLeadingRegistrar(&testSys, ts.URL, false)
+		if result != false {
+			t.Errorf("Expected %t, got: %t", false, result)
+		}
+	*/
+
+	statusCode = http.StatusOK
+	responseBody = "wrong response"
+	testURL = ts.URL
+	result = DiscoverLeadingRegistrar(&testSys, testURL, false)
+	if result != false {
+		t.Errorf("Expected %t, got: %t", false, result)
+	}
+
+	/*
+		statusCode = http.StatusBadRequest
+		responseBody = "wrong response"
+		result = DiscoverLeadingRegistrar(&testSys, ts.URL, false)
+		if result != false {
+			t.Errorf("Expected %t, got: %t", false, result)
+		}
+	*/
+
+	statusCode = http.StatusOK
+	responseBody = "lead Service Registrar since"
+	testURL = ts.URL
+	result = DiscoverLeadingRegistrar(&testSys, testURL, true)
+	if result != true {
+		t.Errorf("Expected %t, got: %t", true, result)
+	}
+
+	statusCode = http.StatusOK
+	responseBody = "wrong response"
+	testURL = ts.URL
+	result = DiscoverLeadingRegistrar(&testSys, testURL, true)
+	if result != false {
+		t.Errorf("Expected %t, got: %t", false, result)
+	}
+
+	/*
+		statusCode = http.StatusBadRequest
+		responseBody = "lead Service Registrar since"
+		result = DiscoverLeadingRegistrar(&testSys, ts.URL, true)
+		if result != false {
+			t.Errorf("Expected %t, got: %t", false, result)
+		}
+
+		statusCode = http.StatusBadRequest
+		responseBody = "wrong response"
+		result = DiscoverLeadingRegistrar(&testSys, ts.URL, true)
+		if result != false {
+			t.Errorf("Expected %t, got: %t", false, result)
+		}
+	*/
+}
diff --git a/usecases/sample_test.go b/usecases/sample_test.go
deleted file mode 100644
index cd44f08..0000000
--- a/usecases/sample_test.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package usecases
-
-import (
-	"net/http"
-	"testing"
-)
-
-// mockTransport is used for replacing the default network Transport (used by
-// http.DefaultClient) and it will intercept network requests.
-type mockTransport struct {
-	resp *http.Response
-}
-
-func newMockTransport(resp *http.Response) mockTransport {
-	t := mockTransport{
-		resp: resp,
-	}
-	// Hijack the default http client so no actual http requests are sent over the network
-	http.DefaultClient.Transport = t
-	return t
-}
-
-// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
-// It prevents the request from being sent over the network and count how many times
-// a domain was requested.
-func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-	t.resp.Request = req
-	return t.resp, nil
-}
-
-func TestSample(t *testing.T) {
-	return
-}

From d972543d327924d76b80d7fa502359e20c123264 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 10 Jun 2025 13:13:32 +0200
Subject: [PATCH 016/186] Finished test for Search4Service

---
 usecases/serviceDiscovery.go      |  35 +++++--
 usecases/serviceDiscovery_test.go | 158 +++++++++++++++++++++++-------
 2 files changed, 148 insertions(+), 45 deletions(-)

diff --git a/usecases/serviceDiscovery.go b/usecases/serviceDiscovery.go
index 135cc02..25d1f8a 100644
--- a/usecases/serviceDiscovery.go
+++ b/usecases/serviceDiscovery.go
@@ -81,6 +81,18 @@ func ExtractQuestForm(bodyBytes []byte) (rec forms.ServiceQuest_v1, err error) {
 	return
 }
 
+func sendHttpReq(method string, oURL string, jsonQF []byte, ctx context.Context) (resp *http.Response, err error) {
+	req, err := http.NewRequest(method, oURL, bytes.NewBuffer(jsonQF))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json") // set the Content-Type header
+	req = req.WithContext(ctx)                         // associate the cancellable context with the request
+
+	resp, err = http.DefaultClient.Do(req)
+	return
+}
+
 // Search4Service requests from the core systems the address of resources's services that meet the need
 func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocation forms.ServicePoint_v1, err error) {
 
@@ -101,17 +113,20 @@ func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocat
 		log.Printf("problem encountered when marshalling the service quest to the Orchestrator at %s\n", oURL)
 		return servLocation, err
 	}
-	// prepare the request
-	req, err := http.NewRequest(http.MethodPost, oURL, bytes.NewBuffer(jsonQF))
-	if err != nil {
-		return servLocation, err
-	}
-	req.Header.Set("Content-Type", "application/json") // set the Content-Type header
-	req = req.WithContext(ctx)                         // associate the cancellable context with the request
+	/*
+		// prepare the request
+		req, err := http.NewRequest(http.MethodPost, oURL, bytes.NewBuffer(jsonQF))
+		if err != nil {
+			return servLocation, err
+		}
+		req.Header.Set("Content-Type", "application/json") // set the Content-Type header
+		req = req.WithContext(ctx)                         // associate the cancellable context with the request
 
-	// Send the request /////////////////////////////////
-	//client := &http.Client{}
-	resp, err := http.DefaultClient.Do(req) // changed to DefaultClient to simplify testing
+		// Send the request /////////////////////////////////
+		//client := &http.Client{}
+		resp, err := http.DefaultClient.Do(req) // changed to DefaultClient to simplify testing
+	*/
+	resp, err := sendHttpReq(http.MethodPost, oURL, jsonQF, ctx) // Moved above codeblock into help function, to improve readability
 	if err != nil {
 		return servLocation, err
 	}
diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 48291fe..4f68d02 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -16,12 +16,17 @@ import (
 // mockTransport is used for replacing the default network Transport (used by
 // http.DefaultClient) and it will intercept network requests.
 type mockTransport struct {
-	resp *http.Response
+	returnError bool
+	resp        *http.Response
+	hits        map[string]int
+	err         error
 }
 
-func newMockTransport(resp *http.Response) mockTransport {
+func newMockTransport(resp *http.Response, retErr bool, err error) mockTransport {
 	t := mockTransport{
-		resp: resp,
+		returnError: retErr,
+		resp:        resp,
+		err:         err,
 	}
 	// Hijack the default http client so no actual http requests are sent over the network
 	http.DefaultClient.Transport = t
@@ -32,10 +37,20 @@ func newMockTransport(resp *http.Response) mockTransport {
 // It prevents the request from being sent over the network and count how many times
 // a domain was requested.
 func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	if t.err != nil {
+		return nil, t.err
+	}
+	if t.returnError != false {
+		req.GetBody = func() (io.ReadCloser, error) {
+			return nil, errHTTP
+		}
+	}
 	t.resp.Request = req
 	return t.resp, nil
 }
 
+var errHTTP error = fmt.Errorf("bad http request")
+
 type mockUnitAsset struct {
 }
 
@@ -72,7 +87,7 @@ func TestServQuestForms(t *testing.T) {
 	}
 }
 
-func createTestSystem(ctx context.Context) components.System {
+func createTestSystem(ctx context.Context, broken bool) components.System {
 	// instantiate the System
 	sys := components.NewSystem("testSystem", ctx)
 
@@ -83,12 +98,22 @@ func createTestSystem(ctx context.Context) components.System {
 		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
 		InfoLink:    "https://for.testing.purposes",
 	}
-	orchestrator := &components.CoreSystem{
-		Name: "orchestrator",
-		Url:  "https://orchestator",
-	}
-	sys.CoreS = []*components.CoreSystem{
-		orchestrator,
+	if broken == false {
+		orchestrator := &components.CoreSystem{
+			Name: "orchestrator",
+			Url:  "https://orchestator",
+		}
+		sys.CoreS = []*components.CoreSystem{
+			orchestrator,
+		}
+	} else {
+		orchestrator := &components.CoreSystem{
+			Name: "orchestrator",
+			Url:  brokenUrl,
+		}
+		sys.CoreS = []*components.CoreSystem{
+			orchestrator,
+		}
 	}
 	return sys
 }
@@ -96,7 +121,7 @@ func createTestSystem(ctx context.Context) components.System {
 func TestFillQuestForm(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	testSys := createTestSystem(ctx)
+	testSys := createTestSystem(ctx, false)
 	mua := mockUnitAsset{}
 	questForm := FillQuestForm(&testSys, mua, "TestDef", "TestProtocol")
 	// Loop through the details in questForm and mua (mockUnitAsset), error if they're same
@@ -117,18 +142,6 @@ type testBodyHasVersion struct {
 }
 type testBodyNoVersion struct{}
 
-// Create a error reader to break json.unmarshal
-type errReader int
-
-var errBodyRead error = fmt.Errorf("bad body read")
-
-func (errReader) Read(p []byte) (n int, err error) {
-	return 0, errBodyRead
-}
-func (errReader) Close() error {
-	return nil
-}
-
 func TestExtractQuestForm(t *testing.T) {
 	body := testBodyHasVersion{
 		Version: "ServiceQuest_v1",
@@ -176,24 +189,47 @@ func TestExtractQuestForm(t *testing.T) {
 	}
 }
 
-func createTestForm(f forms.ServiceQuest_v1) {
+func createServicePointTestForm() forms.ServicePoint_v1 {
+	var f forms.ServicePoint_v1
 	f.NewForm()
-	f.SysId = 999
-	f.RequesterName = "Requester"
+	f.Version = "ServicePoint_v1"
+	f.ServLocation = "TestService"
 	f.ServiceDefinition = "TestService"
-	f.Protocol = ""
 	f.Details = map[string][]string{
 		"Details": {"detail_1", "detail_2"},
 	}
-	f.Version = "SignalA_v1a"
+	return f
 }
 
+// Create a error reader to break json.unmarshal
+type errReader int
+
+var errBodyRead error = fmt.Errorf("bad body read")
+
+func (errReader) Read(p []byte) (n int, err error) {
+	return 0, errBodyRead
+}
+func (errReader) Close() error {
+	return nil
+}
+
+var brokenUrl = string([]byte{0x7f})
+
+/*
+type ServiceQuest_v1 struct {
+	SysId             int                 `json:"systemId"`
+	RequesterName     string              `json:"requesterName"`
+	ServiceDefinition string              `json:"serrviceDefinition"`
+	Protocol          string              `json:"protocol"`
+	Details           map[string][]string `json:"details"`
+	Version           string              `json:"version"`
+	Break             any                 `json:"break"`
+}
+*/
+
 func TestSearch4Service(t *testing.T) {
 	// Best case, everything pass
-	var f forms.ServicePoint_v1
-	f.NewForm()
-	f.Version = "ServicePoint_v1"
-	f.ServLocation = "TestService"
+	f := createServicePointTestForm()
 	// Create mock response from orchestrator
 	fakeBody, err := json.Marshal(f)
 	if err != nil {
@@ -204,10 +240,9 @@ func TestSearch4Service(t *testing.T) {
 		StatusCode: 200,
 		Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
 	}
-	newMockTransport(resp)
+	newMockTransport(resp, false, nil)
 	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx)
+	testSys := createTestSystem(ctx, false)
 	var qForm forms.ServiceQuest_v1
 	serviceForm, err := Search4Service(qForm, &testSys)
 	if err != nil {
@@ -216,4 +251,57 @@ func TestSearch4Service(t *testing.T) {
 	if serviceForm.ServLocation != f.ServLocation {
 		t.Errorf("Expected %s, got: %s", f.ServLocation, serviceForm.ServLocation)
 	}
+	cancel()
+
+	// Error at "prepare the payload to perform a service quest"
+	// Untested because I found no way of breaking json.Marshal, without making big changes to the form
+
+	// "prepare the request" and "Send the request" codeblocks have been moved into a helpfunction, still gets tested though
+	// Error at "prepare the request" part of sendHttpReq()
+	newMockTransport(resp, false, nil)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, true)
+	qForm.NewForm()
+	serviceForm, err = Search4Service(qForm, &testSys)
+	if err == nil {
+		t.Errorf("Expected error on first marshal, got none")
+	}
+	cancel()
+
+	// Error at "Send the request" part of sendHttpReq()
+	newMockTransport(resp, true, errHTTP)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	qForm.NewForm()
+	serviceForm, err = Search4Service(qForm, &testSys)
+	if err == nil {
+		t.Errorf("Expected error on first marshal, got none")
+	}
+	cancel()
+
+	// Error at "Read the response", io.ReadAll()
+	f = createServicePointTestForm()
+	resp.Body = errReader(0)
+	newMockTransport(resp, false, nil)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	qForm.NewForm()
+	serviceForm, err = Search4Service(qForm, &testSys)
+	if err == nil {
+		t.Errorf("Expected error on first marshal, got none")
+	}
+	cancel()
+
+	// Error at "Read the response", ExtractDiscoveryForm()
+	f = createServicePointTestForm()
+	resp.Body = io.NopCloser(strings.NewReader(string("test")))
+	newMockTransport(resp, false, nil)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	qForm.NewForm()
+	serviceForm, err = Search4Service(qForm, &testSys)
+	if err == nil {
+		t.Errorf("Expected error on first marshal, got none")
+	}
+	cancel()
 }

From edd538a953e37d325d14dd78141d806bb22b5337 Mon Sep 17 00:00:00 2001
From: vanDeventer <jan.van.deventer@ltu.se>
Date: Tue, 27 May 2025 14:12:40 +0200
Subject: [PATCH 017/186] redo configuration to have configurable services

---
 components/{device.go => host.go}     |   0
 components/husk.go                    |   2 +-
 components/service.go                 |  11 +-
 components/system.go                  |  54 ++++++++--
 components/uasset.go                  |   5 +
 usecases/authentication.go            |  57 ++++++----
 usecases/configuration.go             | 146 ++++++++++++++------------
 usecases/docs.go                      |  22 ++--
 usecases/registration.go              |   2 +
 usecases/serversNhandlers.go          |   8 +-
 usecases/{packing.go => utilities.go} |   8 +-
 11 files changed, 202 insertions(+), 113 deletions(-)
 rename components/{device.go => host.go} (100%)
 rename usecases/{packing.go => utilities.go} (94%)

diff --git a/components/device.go b/components/host.go
similarity index 100%
rename from components/device.go
rename to components/host.go
diff --git a/components/husk.go b/components/husk.go
index 431562a..0c56363 100644
--- a/components/husk.go
+++ b/components/husk.go
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2024 Synecdoque
+ * Copyright (c) 2025 Synecdoque
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
diff --git a/components/service.go b/components/service.go
index 05ac67d..2243f2d 100644
--- a/components/service.go
+++ b/components/service.go
@@ -26,7 +26,7 @@ package components
 type Service struct {
 	ID            int                 `json:"-"`                  // Id assigned by the Service Registrar
 	Definition    string              `json:"definition"`         // Service definition or purpose
-	SubPath       string              `json:"-"`                  // The URL subpath after the resource's
+	SubPath       string              `json:"subpath"`            // The URL subpath after the resource's
 	Details       map[string][]string `json:"details"`            // Metadata or details about the service
 	RegPeriod     int                 `json:"registrationPeriod"` // The period until the registrar is expecting a sign of life
 	RegTimestamp  string              `json:"-"`                  // the creation date in the Service Registry to ensure that reRegistration is with the same record
@@ -113,10 +113,11 @@ func MergeDetails(map1, map2 map[string][]string) map[string][]string {
 
 // A Cervice is a consumed service
 type Cervice struct {
-	Definition string
-	Details    map[string][]string
-	Nodes      map[string][]string
-	Protos     []string
+	IReferentce string // Internal reference when consuming more than one service of the same type
+	Definition  string // Service definition or purpose
+	Details     map[string][]string
+	Nodes       map[string][]string
+	Protos      []string
 }
 
 // Cervises is a collection of "Cervice" structs
diff --git a/components/system.go b/components/system.go
index abccc4b..a9ac4cb 100644
--- a/components/system.go
+++ b/components/system.go
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2024 Synecdoque
+ * Copyright (c) 2025 Synecdoque
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,14 +24,17 @@ package components
 import (
 	"context"
 	"fmt"
+	"io"
+	"net/http"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 )
 
-// System struct aggragates an Arrowhead compliant system
+// System struct aggregates an Arrowhead compliant system
 type System struct {
-	Name          string                `json:"systemname"`
+	Name          string                `json:"systemName"`
 	Host          *HostingDevice        // the system runs on a device
 	Husk          *Husk                 // the system aggregates a "husk" (a wrapper or a shell)
 	UAssets       map[string]*UnitAsset // the system aggregates "asset", which is made up of one or more unit-asset
@@ -43,9 +46,8 @@ type System struct {
 
 // CoreSystem struct holds details about the core system included in the configuration file
 type CoreSystem struct {
-	Name        string `json:"coresystem"`
-	Url         string `json:"url"`
-	Certificate string `json:"-"`
+	Name string `json:"coreSystem"`
+	Url  string `json:"url"`
 }
 
 // NewSystem instantiates the new system and gathers the host information
@@ -61,6 +63,46 @@ func NewSystem(name string, ctx context.Context) System {
 	return newSystem
 }
 
+// GetRunningCoreSystemURL returns the URL of a running core system based on the provided type.
+// When systemType is "serviceregistrar", it verifies the service is the lead registrar by checking
+// its /status endpoint response. For other core system types, it simply tests that the URL is accessible.
+func GetRunningCoreSystemURL(sys *System, systemType string) (string, error) {
+	for _, core := range sys.CoreS {
+		if core.Name == systemType {
+			// Special logic for the service registrar: check the status endpoint
+			if systemType == "serviceregistrar" {
+				statusURL := core.Url + "/status"
+				resp, err := http.Get(statusURL)
+				if err != nil {
+					fmt.Printf("error checking service registrar status at %s: %v\n", statusURL, err)
+					continue // Try the next core system instance, if any.
+				}
+				bodyBytes, err := io.ReadAll(resp.Body)
+				resp.Body.Close() // Always close the response body when done.
+				if err != nil {
+					fmt.Printf("error reading response from %s: %v\n", statusURL, err)
+					continue
+				}
+				// Verify status response
+				if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
+					fmt.Printf("Lead service registrar found at: %s\n", core.Url)
+					return core.Url, nil
+				}
+			} else {
+				// For other core systems, verify that the service is accessible.
+				resp, err := http.Get(core.Url)
+				if err != nil {
+					fmt.Printf("error checking %s at %s: %v\n", systemType, core.Url, err)
+					continue
+				}
+				resp.Body.Close()
+				return core.Url, nil
+			}
+		}
+	}
+	return "", fmt.Errorf("failed to locate running core system of type %s", systemType)
+}
+
 // The following code is used only for issues support on GitHub @sdoque --------------------------
 var (
 	AppName   string
diff --git a/components/uasset.go b/components/uasset.go
index 300ba79..65ee1e0 100644
--- a/components/uasset.go
+++ b/components/uasset.go
@@ -33,3 +33,8 @@ type UnitAsset interface {
 	GetDetails() map[string][]string
 	Serving(w http.ResponseWriter, r *http.Request, servicePath string)
 }
+
+// HasTraits is an interface that defines a method to get traits of a UnitAsset.
+type HasTraits interface {
+	GetTraits() any // or interface{} in older Go
+}
diff --git a/usecases/authentication.go b/usecases/authentication.go
index 8138fd9..0daec0e 100644
--- a/usecases/authentication.go
+++ b/usecases/authentication.go
@@ -29,6 +29,7 @@ import (
 	"encoding/pem"
 	"fmt"
 	"log"
+	"net"
 	"net/http"
 	"strings"
 
@@ -40,18 +41,28 @@ func RequestCertificate(sys *components.System) {
 	// Generate ECDSA Private Key
 	privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 	if err != nil {
-		log.Fatalf("Failed to generate private key: %v", err)
+		log.Fatalf("Failed to generate private key: %v\n", err)
 	}
 	sys.Husk.Pkey = privateKey
 
+	dnsNames := []string{"localhost"}
+	var ipAddrs []net.IP
+	for _, ipStr := range sys.Host.IPAddresses {
+		ip := net.ParseIP(ipStr)
+		if ip != nil {
+			ipAddrs = append(ipAddrs, ip)
+		}
+	}
 	csrTemplate := x509.CertificateRequest{
 		Subject:            sys.Husk.DName,
+		DNSNames:           dnsNames, // this is the SAN DNS
+		IPAddresses:        ipAddrs,  // this is the SAN IPs
 		SignatureAlgorithm: x509.ECDSAWithSHA256,
 	}
 
 	csrBytes, err := x509.CreateCertificateRequest(rand.Reader, &csrTemplate, privateKey)
 	if err != nil {
-		log.Fatalf("Failed to create CSR: %v", err)
+		log.Fatalf("Failed to create CSR: %v\n", err)
 		return
 	}
 
@@ -61,7 +72,7 @@ func RequestCertificate(sys *components.System) {
 	// Send the CSR to the CA and receive the certificate in response
 	response, err := sendCSR(sys, csrPEM)
 	if err != nil {
-		log.Printf("certification failure: %v", err)
+		log.Printf("certification failure: %v\n", err)
 		return
 	}
 
@@ -71,7 +82,7 @@ func RequestCertificate(sys *components.System) {
 	// Get CA's certificate
 	caCert, err := getCACertificate(sys)
 	if err != nil {
-		log.Printf("failed to obtain CA's certificate: %v", err)
+		log.Printf("failed to obtain CA's certificate: %v\n", err)
 		return
 	}
 	sys.Husk.CA_cert = caCert
@@ -79,13 +90,13 @@ func RequestCertificate(sys *components.System) {
 	// Load CA certificate
 	caCertPool := x509.NewCertPool()
 	if ok := caCertPool.AppendCertsFromPEM([]byte(caCert)); !ok {
-		log.Fatalf("Failed to append CA certificate to pool")
+		log.Fatalf("Failed to append CA certificate to pool\n")
 	}
 
 	// Prepare the client's certificate and key for TLS configuration
 	clientCert, err := prepareClientCertificate(sys.Husk.Certificate, sys.Husk.Pkey)
 	if err != nil {
-		log.Fatalf("Failed to prepare client certificate: %v", err)
+		log.Fatalf("Failed to prepare client certificate: %v\n", err)
 	}
 
 	// Configure Transport Layer Security (TLS)
@@ -101,7 +112,7 @@ func RequestCertificate(sys *components.System) {
 	fmt.Printf("System %s's parsed Certificate:\n", sys.Name)
 	cert, err := x509.ParseCertificate(clientCert.Certificate[0])
 	if err != nil {
-		log.Printf("failed to parse certificate: %v", err)
+		log.Printf("failed to parse certificate: %v\n", err)
 		return
 	}
 	fmt.Printf("  Subject: %s\n", cert.Subject)
@@ -109,6 +120,9 @@ func RequestCertificate(sys *components.System) {
 	fmt.Printf("  Serial Number: %d\n", cert.SerialNumber)
 	fmt.Printf("  Not Before: %s\n", cert.NotBefore)
 	fmt.Printf("  Not After: %s\n", cert.NotAfter)
+	fmt.Printf("  DNS Names: %v\n", cert.DNSNames)
+	fmt.Printf("  IP Addresses: %v\n", cert.IPAddresses)
+
 }
 
 func sendCSR(sys *components.System, csrPEM []byte) (string, error) {
@@ -149,18 +163,25 @@ func sendCSR(sys *components.System, csrPEM []byte) (string, error) {
 
 // getCACertificate gets the CA's certificate necessary for the dual server-client authentication in the TLS setup
 func getCACertificate(sys *components.System) (string, error) {
-	var err error
-	coreUAurl := ""
-	for _, cSys := range sys.CoreS {
-		core := cSys
-		if core.Name == "ca" {
-			coreUAurl = core.Url
-		}
-	}
-	if coreUAurl == "" {
-		return "", fmt.Errorf("failed to locate certificate authority: %w", err)
+	// var err error
+	// coreUAurl := ""
+	// for _, cSys := range sys.CoreS {
+	// 	core := cSys
+	// 	if core.Name == "ca" {
+	// 		coreUAurl = core.Url
+	// 	}
+	// }
+	// if coreUAurl == "" {
+	// 	return "", fmt.Errorf("failed to locate certificate authority: %w", err)
+	// }
+
+	// Get the URL of the CA's configuration
+	coreUAurl, err := components.GetRunningCoreSystemURL(sys, "ca") // Assuming the first core system is the CA
+	if err != nil {
+		return "", fmt.Errorf("failed to get CA URL: %w", err)
 	}
-	url := strings.TrimSuffix(coreUAurl, "ification") // the configuration file address to the CA includes the unit asset
+	// Remove the "ification" suffix from the URL to get the CA's address
+	url := strings.TrimSuffix(coreUAurl, "ification")
 
 	// Make a GET request to the CA's endpoint
 	// https://stackoverflow.com/questions/70281883/golang-untaint-url-variable-to-fix-gosec-warning-g107
diff --git a/usecases/configuration.go b/usecases/configuration.go
index ad7e846..fb3f891 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2024 Synecdoque
+ * Copyright (c) 2025 Synecdoque
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,6 @@
 package usecases
 
 import (
-	"crypto/x509/pkix"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -30,14 +29,21 @@ import (
 	"github.com/sdoque/mbaigo/components"
 )
 
-// templateOut is the struct used to prepare the systemconfig.json file
+// configurableAsset is a struct that contains the name of the asset and its
+// configurable details and services
+type ConfigurableAsset struct {
+	Name     string               `json:"name"`
+	Details  map[string][]string  `json:"details"`
+	Services []components.Service `json:"services"`
+	Traits   []json.RawMessage    `json:"traits"`
+}
+
+// templateOut is the stuct used to prepare the systemconfig.json file
 type templateOut struct {
-	CName      string                  `json:"systemname"`
-	UAsset     []components.UnitAsset  `json:"unit_assets"`
-	CServices  []components.Service    `json:"services"`
-	Protocols  map[string]int          `json:"protocolsNports"`
-	PKIdetails pkix.Name               `json:"distinguishedName"`
-	CCoreS     []components.CoreSystem `json:"coreSystems"`
+	CName     string                  `json:"systemname"`
+	Assets    []ConfigurableAsset     `json:"unit_assets"`
+	Protocols map[string]int          `json:"protocolsNports"`
+	CCoreS    []components.CoreSystem `json:"coreSystems"`
 }
 
 // configFileIn is used to extract out the information of the systemconfig.json file
@@ -46,77 +52,95 @@ type templateOut struct {
 type configFileIn struct {
 	CName        string                  `json:"systemname"`
 	rawResources []json.RawMessage       `json:"-"`
-	CServices    []components.Service    `json:"services"`
 	Protocols    map[string]int          `json:"protocolsNports"`
-	PKIdetails   pkix.Name               `json:"distinguishedName"`
 	CCoreS       []components.CoreSystem `json:"coreSystems"`
 }
 
-// Configure read the system configuration JSON file to get the deployment details.
+// Configure reads the system configuration JSON file to get the deployment details.
 // If the file is missing, it generates a default systemconfig.json file and shuts down the system
-func Configure(sys *components.System) ([]json.RawMessage, []components.Service, error) {
-
-	var rawBytes []json.RawMessage        // the mbaigo library does not know about the unit asset's structure (defined in the file thing.go and not part of the library)
-	var servicesList []components.Service // this is the list of services for each unit asset
+func Configure(sys *components.System) ([]json.RawMessage, error) {
 	// prepare content of configuration file
 	var defaultConfig templateOut
 
+	// var servicesList []components.Service // this is the list of services for each unit asset
+
+	var assetTemplate components.UnitAsset
+	for _, ua := range sys.UAssets {
+		assetTemplate = *ua // this creates a copy (value, not reference)
+		break               // stop after the first entry
+	}
+	servicesTemplate := getServicesList(assetTemplate)
+
+	confAsset := ConfigurableAsset{
+		Name:     assetTemplate.GetName(),
+		Details:  assetTemplate.GetDetails(),
+		Services: servicesTemplate,
+	}
+
+	// If the asset exposes traits, serialize them and store as raw JSON
+	if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
+		if traits := assetWithTraits.GetTraits(); traits != nil {
+			traitJSON, err := json.Marshal(traits)
+			if err == nil {
+				confAsset.Traits = []json.RawMessage{traitJSON}
+			} else {
+				fmt.Println("Warning: could not marshal traits:", err)
+			}
+		}
+	}
+
 	defaultConfig.CName = sys.Name
 	defaultConfig.Protocols = sys.Husk.ProtoPort
-	defaultConfig.UAsset = getFirstAsset(sys.UAssets)
-	originalSs := getServicesList(defaultConfig.UAsset[0])
-	defaultConfig.CServices = originalSs
-
-	defaultConfig.PKIdetails.CommonName = "arrowhead.eu"
-	defaultConfig.PKIdetails.Country = []string{"SE"}
-	defaultConfig.PKIdetails.Province = []string{"Norrbotten"}
-	defaultConfig.PKIdetails.Locality = []string{"Luleaa"}
-	defaultConfig.PKIdetails.Organization = []string{"Luleaa University of Technology"}
-	defaultConfig.PKIdetails.OrganizationalUnit = []string{"CPS"}
+	defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
 
 	servReg := components.CoreSystem{
-		Name:        "serviceregistrar",
-		Url:         "http://localhost:20102/serviceregistrar/registry",
-		Certificate: ".X509pubKey",
+		Name: "serviceregistrar",
+		Url:  "http://localhost:20102/serviceregistrar/registry",
 	}
 	orches := components.CoreSystem{
-		Name:        "orchestrator",
-		Url:         "http://localhost:20103/orchestrator/orchestration",
-		Certificate: ".X509pubKey",
+		Name: "orchestrator",
+		Url:  "http://localhost:20103/orchestrator/orchestration",
 	}
 	ca := components.CoreSystem{
-		Name:        "ca",
-		Url:         "http://localhost:20100/ca/certification",
-		Certificate: ".X509pubKey",
+		Name: "ca",
+		Url:  "http://localhost:20100/ca/certification",
 	}
-	coreSystems := []components.CoreSystem{servReg, orches, ca}
+	maitreD := components.CoreSystem{
+		Name: "maitreD",
+		Url:  "http://localhost:20101/maitreD/maitreD",
+	}
+	// add the core systems to the configuration file
+	// the system is part of a local cloud with mandatory core systems
+	coreSystems := []components.CoreSystem{servReg, orches, ca, maitreD}
 	defaultConfig.CCoreS = coreSystems
 
+	var rawBytes []json.RawMessage // the mbaigo library does not know about the unit asset's structure (defined in the file thing.go and not part of the library)
+
 	// open the configuration file or create one with the default content prepared above
 	systemConfigFile, err := os.Open("systemconfig.json")
 
 	if err != nil { // could not find the systemconfig.json so a default one is being created
 		defaultConfigFile, err := os.Create("systemconfig.json")
 		if err != nil {
-			return rawBytes, servicesList, err
+			return rawBytes, err
 		}
 		defer defaultConfigFile.Close()
-		systemconfigjson, err := json.MarshalIndent(defaultConfig, "", "   ")
+		systemconfigjson, err := json.MarshalIndent(defaultConfig, "", "     ")
 		if err != nil {
-			return rawBytes, servicesList, err
+			return rawBytes, err
 		}
 		nBytes, err := defaultConfigFile.Write(systemconfigjson)
 		if err != nil {
-			return rawBytes, servicesList, err
+			return rawBytes, err
 		}
-		return rawBytes, servicesList, fmt.Errorf("a new configuration file has been written with %d bytes. Please update it and restart the system", nBytes)
+		return rawBytes, fmt.Errorf("a new configuration file has been written with %d bytes. Please update it and restart the system", nBytes)
 	}
 
 	// the system configuration file could be open, read the configurations and pass them on to the system
 	defer systemConfigFile.Close()
 	configBytes, err := os.ReadFile("systemconfig.json")
 	if err != nil {
-		return rawBytes, servicesList, err
+		return rawBytes, err
 	}
 
 	// the challenge is that the definition of the unit asset is unknown to the mbaigo library and only known to the system that invokes the library
@@ -130,13 +154,13 @@ func Configure(sys *components.System) ([]json.RawMessage, []components.Service,
 		Alias: (*Alias)(&configurationIn),
 	}
 	if err := json.Unmarshal(configBytes, aux); err != nil {
-		return rawBytes, servicesList, err
+		return rawBytes, err
 	}
 	if len(aux.Resources) > 0 {
 		configurationIn.rawResources = aux.Resources
 	} else {
 		var rawMessages []json.RawMessage
-		for _, s := range defaultConfig.UAsset {
+		for _, s := range defaultConfig.Assets {
 			// convert the struct to JSON-encoded byte array
 			jsonBytes, err := json.Marshal(s)
 			if err != nil {
@@ -148,34 +172,13 @@ func Configure(sys *components.System) ([]json.RawMessage, []components.Service,
 	}
 
 	sys.Name = configurationIn.CName
-	sys.Husk.DName = configurationIn.PKIdetails
 	sys.Husk.ProtoPort = configurationIn.Protocols
 	for _, ccore := range configurationIn.CCoreS {
 		newCore := ccore
 		sys.CoreS = append(sys.CoreS, &newCore)
 	}
 
-	// update the services (e.g., re-registration period, costs, or units)
-	for i := range configurationIn.CServices {
-		for _, originalService := range originalSs {
-			if originalService.Definition == configurationIn.CServices[i].Definition {
-				configurationIn.CServices[i].Merge(&originalService) // keep the original definition and subpath as the original ones
-			}
-		}
-	}
-	servicesList = configurationIn.CServices
-
-	return configurationIn.rawResources, servicesList, nil
-}
-
-// getFirstAsset returns the first key-value pair in the Assets map
-func getFirstAsset(assetMap map[string]*components.UnitAsset) []components.UnitAsset {
-	var assetList []components.UnitAsset
-	for key := range assetMap {
-		assetList = append(assetList, *assetMap[key])
-		return assetList
-	}
-	return assetList
+	return configurationIn.rawResources, nil
 }
 
 // getServicesList() returns the original list of services
@@ -187,3 +190,14 @@ func getServicesList(uat components.UnitAsset) []components.Service {
 	}
 	return serviceList
 }
+
+// MakeServiceMap() creates a map of services from a slice of services
+// The map is indexed by the service subpath
+func MakeServiceMap(services []components.Service) map[string]*components.Service {
+	serviceMap := make(map[string]*components.Service)
+	for i := range services {
+		svc := services[i] // take the address of the element in the slice
+		serviceMap[svc.SubPath] = &svc
+	}
+	return serviceMap
+}
diff --git a/usecases/docs.go b/usecases/docs.go
index 8212482..13a44c1 100644
--- a/usecases/docs.go
+++ b/usecases/docs.go
@@ -55,15 +55,19 @@ func SysHateoas(w http.ResponseWriter, req *http.Request, sys components.System)
 		text += "<li><b><a href=\"http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(sys.Husk.ProtoPort["http"]) + "/" + sys.Name + "/" + (*unitasset).GetName() + "/doc" + "\">" + (*unitasset).GetName() + "</a></b> with details " + metaservice + "</li>\n"
 	}
 
-	text += "</ul> having the following services:<ul>\n"
-	servicesList := getServicesList(getFirstAsset(*assetList)[0])
-	for _, service := range servicesList {
-		metaservice := ""
-		for key, values := range service.Details {
-			metaservice += key + ": " + fmt.Sprintf("%v", values) + " "
-		}
-		text += "<li><b>" + service.Definition + "</b> with details: " + metaservice + "</li>\n"
-	}
+	// This part of the code is commented out because it is not used in the current implementation because the assets on a PLC might have different services
+	// ======================================
+	// text = "</ul> having the following services:<ul>"
+	// w.Write([]byte(text))
+	// servicesList := getServicesList(getFirstAsset(*assetList)[0])
+	// for _, service := range servicesList {
+	// 	metaservice := ""
+	// 	for key, values := range service.Details {
+	// 		metaservice += key + ": " + fmt.Sprintf("%v", values) + " "
+	// 	}
+	// 	serviceURI := "<li><b>" + service.Definition + "</b> with details: " + metaservice + "</li>"
+	// 	w.Write([]byte(serviceURI))
+	// }
 
 	text += "</ul> <p> The services can be accessed using the following protocols with their respective bound ports:</p><ul>\n"
 	for protocol, port := range sys.Husk.ProtoPort {
diff --git a/usecases/registration.go b/usecases/registration.go
index 3c0ebcb..ed07679 100755
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -49,6 +49,7 @@ func RegisterServices(sys *components.System) {
 		ticker := time.NewTicker(5 * time.Second)
 		defer ticker.Stop()
 		for {
+			// Check if the leading registrar is already known
 			if leadingRegistrar != nil {
 				resp, err := http.Get(leadingRegistrar.Url + "/status")
 				if err != nil {
@@ -74,6 +75,7 @@ func RegisterServices(sys *components.System) {
 					log.Println("lost previous leading registrar")
 				}
 			} else {
+				// If the leading registrar is not known, check all core systems
 				for _, cSys := range sys.CoreS {
 					core := cSys
 					if core.Name == "serviceregistrar" {
diff --git a/usecases/serversNhandlers.go b/usecases/serversNhandlers.go
index f5e19bb..928f1c0 100644
--- a/usecases/serversNhandlers.go
+++ b/usecases/serversNhandlers.go
@@ -37,7 +37,7 @@ import (
 	"github.com/sdoque/mbaigo/forms"
 )
 
-// SetoutServers setup the http and https servers and starts them
+// SetoutServers setups the http and https servers and starts them
 func SetoutServers(sys *components.System) (err error) {
 	// get the servers port number (from configuration file)
 	httpPort := sys.Husk.ProtoPort["http"]
@@ -177,7 +177,7 @@ func ResourceHandler(sys *components.System, w http.ResponseWriter, r *http.Requ
 		return
 	}
 
-	resourceName := parts[2]
+	assetName := parts[2]
 	servicePath := ""
 	if len(parts) > 3 {
 		servicePath = parts[3]
@@ -191,9 +191,9 @@ func ResourceHandler(sys *components.System, w http.ResponseWriter, r *http.Requ
 	case 3:
 		handleThreeParts(w, r, parts[2], sys)
 	case 4:
-		handleFourParts(w, r, resourceName, servicePath, sys)
+		handleFourParts(w, r, assetName, servicePath, sys)
 	case 5:
-		handleFiveParts(w, r, resourceName, servicePath, record, sys)
+		handleFiveParts(w, r, assetName, servicePath, record, sys)
 	default:
 		http.Error(w, "Invalid request", http.StatusBadRequest)
 	}
diff --git a/usecases/packing.go b/usecases/utilities.go
similarity index 94%
rename from usecases/packing.go
rename to usecases/utilities.go
index 6f1252f..6990274 100644
--- a/usecases/packing.go
+++ b/usecases/utilities.go
@@ -78,12 +78,12 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, &rawData); err != nil {
-			log.Printf("Error unmarshalling JSON: %v", err)
+			log.Printf("Error unmarshaling JSON: %v", err)
 			return nil, err
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, &rawData); err != nil {
-			log.Printf("Error unmarshalling XML: %v", err)
+			log.Printf("Error unmarshaling XML: %v", err)
 			return nil, err
 		}
 	default:
@@ -109,12 +109,12 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, formInstance); err != nil {
-			log.Printf("Error unmarshalling JSON into form: %v", err)
+			log.Printf("Error unmarshaling JSON into form: %v", err)
 			return nil, err
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, formInstance); err != nil {
-			log.Printf("Error unmarshalling XML into form: %v", err)
+			log.Printf("Error unmarshaling XML into form: %v", err)
 			return nil, err
 		}
 	}

From ba1486a804b7fb53fdbd956cebf2ffd0d61ba7f9 Mon Sep 17 00:00:00 2001
From: vanDeventer <jan.van.deventer@ltu.se>
Date: Tue, 27 May 2025 17:01:00 +0200
Subject: [PATCH 018/186] cleaning up DName and preparing for naming convention

---
 components/husk.go    |  2 +-
 usecases/utilities.go | 49 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/components/husk.go b/components/husk.go
index 0c56363..ddc26ff 100644
--- a/components/husk.go
+++ b/components/husk.go
@@ -35,7 +35,7 @@ type Husk struct {
 	Certificate string              `json:"-"`
 	CA_cert     string              `json:"-"`
 	TlsConfig   *tls.Config         `json:"-"` // client side mutual TLS configuration
-	DName       pkix.Name           `json:"distinguishedName"`
+	DName       pkix.Name           `json:"-"`
 	Details     map[string][]string `json:"details"`
 	ProtoPort   map[string]int      `json:"protoPort"`
 	InfoLink    string              `json:"onlineDocumentation"`
diff --git a/usecases/utilities.go b/usecases/utilities.go
index 6990274..6307265 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -28,6 +28,7 @@ import (
 	"log"
 	"reflect"
 	"strings"
+	"unicode"
 
 	"github.com/sdoque/mbaigo/forms"
 )
@@ -121,3 +122,51 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 
 	return formInstance, nil
 }
+
+// ------- Naming Conventions Tools -------
+
+// ToCamel converts PascalCase to camelCase.
+func ToCamel(s string) string {
+	if s == "" {
+		return s
+	}
+	runes := []rune(s)
+	runes[0] = unicode.ToLower(runes[0])
+	return string(runes)
+}
+
+// ToPascal converts camelCase to PascalCase.
+func ToPascal(s string) string {
+	if s == "" {
+		return s
+	}
+	runes := []rune(s)
+	runes[0] = unicode.ToUpper(runes[0])
+	return string(runes)
+}
+
+// IsFirstLetterUpper returns true if the first rune is uppercase.
+func IsFirstLetterUpper(s string) bool {
+	if s == "" {
+		return false
+	}
+	return unicode.IsUpper([]rune(s)[0])
+}
+
+// IsFirstLetterLower returns true if the first rune is lowercase.
+func IsFirstLetterLower(s string) bool {
+	if s == "" {
+		return false
+	}
+	return unicode.IsLower([]rune(s)[0])
+}
+
+// IsPascalCase returns true if the string starts with an uppercase letter.
+func IsPascalCase(s string) bool {
+	return IsFirstLetterUpper(s)
+}
+
+// IsCamelCase returns true if the string starts with a lowercase letter.
+func IsCamelCase(s string) bool {
+	return IsFirstLetterLower(s)
+}

From 3b07419f5ffe77427edef52133ca7218741a5fd6 Mon Sep 17 00:00:00 2001
From: vanDeventer <jan.van.deventer@ltu.se>
Date: Sat, 7 Jun 2025 09:47:04 +0200
Subject: [PATCH 019/186] adding local ontologies

---
 forms/fileForms.go           |  4 ++++
 usecases/kgraphing.go        | 22 ++++++++++++++++++++--
 usecases/serversNhandlers.go |  9 +++++++--
 3 files changed, 31 insertions(+), 4 deletions(-)

diff --git a/forms/fileForms.go b/forms/fileForms.go
index 425fcaa..207ac1b 100644
--- a/forms/fileForms.go
+++ b/forms/fileForms.go
@@ -81,6 +81,10 @@ func TransferFile(w http.ResponseWriter, r *http.Request) {
 		contentType = "application/zip"
 	case ".txt":
 		contentType = "text/plain"
+	case ".owl":
+		contentType = "application/rdf+xml"
+	case ".ttl":
+		contentType = "text/turtle"
 	case ".html", ".htm":
 		contentType = "text/html"
 	case ".csv":
diff --git a/usecases/kgraphing.go b/usecases/kgraphing.go
index c22d851..f7ca517 100644
--- a/usecases/kgraphing.go
+++ b/usecases/kgraphing.go
@@ -29,6 +29,7 @@ package usecases
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 	"strconv"
 	"strings"
@@ -126,6 +127,23 @@ func modelUAsset(sys *components.System) string {
 
 		details := (*asset).GetDetails()
 		for key, values := range details {
+			fmt.Printf("key: %s, values: %v\n", key, values)
+			if strings.HasSuffix(key, ":") {
+				for _, value := range values {
+					if value == "" {
+						log.Printf("Warning: empty value for key '%s' in asset '%s'. Skipping.", key, assetName)
+						continue
+					}
+					relationship := value[0] // byte
+					reference := value[1:]   // string (from second character onward)
+
+					switch relationship {
+					case '=': // single quotes for byte comparison
+						assetModels += fmt.Sprintf("    owl:sameAs %s ;\n", reference)
+					}
+				}
+				continue
+			}
 			for _, value := range values {
 				if !(strings.HasPrefix(value, "<") && strings.HasSuffix(value, ">")) {
 					value = "alc:" + value
@@ -148,7 +166,7 @@ func modelUAsset(sys *components.System) string {
 		servicesLen := len(services)
 		serviceCount := 0
 		for _, service := range services {
-			assetModels += fmt.Sprintf("    afo:providesService alc:%s_%s_%s", sName, assetName, service.Definition)
+			assetModels += fmt.Sprintf("    afo:providesService alc:%s_%s_%s", sName, assetName, service.SubPath)
 			serviceCount++
 			if serviceCount < servicesLen {
 				assetModels += " ;\n"
@@ -233,7 +251,7 @@ func modelServices(sName string, ua *components.UnitAsset, sys *components.Syste
 		servicesModel += fmt.Sprintf("    afo:hasServiceDefinition \"%s\" ;\n", service.Definition)
 		for protocol, port := range sys.Husk.ProtoPort {
 			if port != 0 {
-				addr := protocol + "://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(port) + "/" + sys.Name + "/" + assetName + "/" + service.Definition
+				addr := protocol + "://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(port) + "/" + sys.Name + "/" + assetName + "/" + service.SubPath
 				servicesModel += fmt.Sprintf("    afo:hasUrl <%s> ;\n", addr)
 			}
 		}
diff --git a/usecases/serversNhandlers.go b/usecases/serversNhandlers.go
index 928f1c0..6341d18 100644
--- a/usecases/serversNhandlers.go
+++ b/usecases/serversNhandlers.go
@@ -245,6 +245,7 @@ func handleFiveParts(w http.ResponseWriter, r *http.Request, resourceName, servi
 	uAsset := *Resource
 	if servicePath == "files" {
 		forms.TransferFile(w, r)
+		// return
 	}
 
 	switch record {
@@ -281,6 +282,10 @@ func findServiceByPath(services map[string]*components.Service, path string) *co
 
 // findServiceByDefinition returns a service's pointer based on its definition
 func findServiceByDefinition(services map[string]*components.Service, definition string) *components.Service {
-	service := services[definition]
-	return service
+	for _, service := range services {
+		if service.Definition == definition {
+			return service
+		}
+	}
+	return nil
 }

From c7e7046e207adbc02f2d495efab37b5e8871c965 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Tue, 10 Jun 2025 13:48:33 +0200
Subject: [PATCH 020/186] removes executable file flags on some source files

---
 components/host.go       | 0
 forms/serviceForms.go    | 0
 forms/systemForms.go     | 0
 usecases/registration.go | 0
 4 files changed, 0 insertions(+), 0 deletions(-)
 mode change 100755 => 100644 components/host.go
 mode change 100755 => 100644 forms/serviceForms.go
 mode change 100755 => 100644 forms/systemForms.go
 mode change 100755 => 100644 usecases/registration.go

diff --git a/components/host.go b/components/host.go
old mode 100755
new mode 100644
diff --git a/forms/serviceForms.go b/forms/serviceForms.go
old mode 100755
new mode 100644
diff --git a/forms/systemForms.go b/forms/systemForms.go
old mode 100755
new mode 100644
diff --git a/usecases/registration.go b/usecases/registration.go
old mode 100755
new mode 100644

From 0abb25a29f229fce05f9190974f57cf3a606c72d Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Tue, 10 Jun 2025 13:52:52 +0200
Subject: [PATCH 021/186] Fixes spelling errors, unhandled errors, and a
 variable url

---
 components/system.go      | 19 +++++++++++++++----
 usecases/configuration.go |  2 +-
 usecases/utilities.go     |  8 ++++----
 3 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/components/system.go b/components/system.go
index a9ac4cb..026a87c 100644
--- a/components/system.go
+++ b/components/system.go
@@ -26,6 +26,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
 	"os/signal"
 	"strings"
@@ -71,18 +72,26 @@ func GetRunningCoreSystemURL(sys *System, systemType string) (string, error) {
 		if core.Name == systemType {
 			// Special logic for the service registrar: check the status endpoint
 			if systemType == "serviceregistrar" {
-				statusURL := core.Url + "/status"
-				resp, err := http.Get(statusURL)
+				// statusURL := core.Url + "/status"
+				statusURL, err := url.Parse(core.Url + "/status")
+				if err != nil {
+					fmt.Printf("error parsing core URL for the service registrar: %s\n", err)
+					continue
+				}
+				resp, err := http.Get(statusURL.String())
 				if err != nil {
 					fmt.Printf("error checking service registrar status at %s: %v\n", statusURL, err)
 					continue // Try the next core system instance, if any.
 				}
 				bodyBytes, err := io.ReadAll(resp.Body)
-				resp.Body.Close() // Always close the response body when done.
+				errClose := resp.Body.Close() // Always close the response body when done.
 				if err != nil {
 					fmt.Printf("error reading response from %s: %v\n", statusURL, err)
 					continue
 				}
+				if errClose != nil {
+					fmt.Printf("error closing response body: %s\n", errClose)
+				}
 				// Verify status response
 				if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
 					fmt.Printf("Lead service registrar found at: %s\n", core.Url)
@@ -95,7 +104,9 @@ func GetRunningCoreSystemURL(sys *System, systemType string) (string, error) {
 					fmt.Printf("error checking %s at %s: %v\n", systemType, core.Url, err)
 					continue
 				}
-				resp.Body.Close()
+				if err = resp.Body.Close(); err != nil {
+					fmt.Printf("error while closing response body: %s\n", err)
+				}
 				return core.Url, nil
 			}
 		}
diff --git a/usecases/configuration.go b/usecases/configuration.go
index fb3f891..a479e05 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -38,7 +38,7 @@ type ConfigurableAsset struct {
 	Traits   []json.RawMessage    `json:"traits"`
 }
 
-// templateOut is the stuct used to prepare the systemconfig.json file
+// templateOut is the struct used to prepare the systemconfig.json file
 type templateOut struct {
 	CName     string                  `json:"systemname"`
 	Assets    []ConfigurableAsset     `json:"unit_assets"`
diff --git a/usecases/utilities.go b/usecases/utilities.go
index 6307265..3825f95 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -79,12 +79,12 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, &rawData); err != nil {
-			log.Printf("Error unmarshaling JSON: %v", err)
+			log.Printf("Error unmarshalling JSON: %v", err)
 			return nil, err
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, &rawData); err != nil {
-			log.Printf("Error unmarshaling XML: %v", err)
+			log.Printf("Error unmarshalling XML: %v", err)
 			return nil, err
 		}
 	default:
@@ -110,12 +110,12 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, formInstance); err != nil {
-			log.Printf("Error unmarshaling JSON into form: %v", err)
+			log.Printf("Error unmarshalling JSON into form: %v", err)
 			return nil, err
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, formInstance); err != nil {
-			log.Printf("Error unmarshaling XML into form: %v", err)
+			log.Printf("Error unmarshalling XML into form: %v", err)
 			return nil, err
 		}
 	}

From 678057a6406a02a1e278b01cb12bafd9e5779779 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Tue, 10 Jun 2025 14:11:15 +0200
Subject: [PATCH 022/186] Continued working on tests in registration.go, making
 commit to pull in changes in registration.go

---
 usecases/registration.go      | 139 ++++++++++++++++++-----------
 usecases/registration_test.go | 159 ++++++++++++++++++++++++++--------
 2 files changed, 213 insertions(+), 85 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index 0dba5ce..7f23fc4 100755
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -134,7 +134,7 @@ func RegisterServices(sys *components.System) {
 	}
 }
 
-func DiscoverLeadingRegistrar(sys *components.System, url string, leadingRegistrarTest bool) (test bool) {
+func DiscoverLeadingRegistrar(sys *components.System, url string, manualTicker time.Duration, leadingRegistrarTest bool) {
 	var leadingRegistrar *components.CoreSystem
 	if leadingRegistrarTest == true {
 		leadingRegistrar = &components.CoreSystem{
@@ -146,65 +146,106 @@ func DiscoverLeadingRegistrar(sys *components.System, url string, leadingRegistr
 	// Create a buffered channel for the pointer to the leading service registrar
 	registrarStream := make(chan *components.CoreSystem, 1)
 	defer close(registrarStream)
-	ticker := time.NewTicker(5 * time.Second)
+	ticker := time.NewTicker(manualTicker)
 	defer ticker.Stop()
-	if leadingRegistrar != nil {
-		//resp, err := http.Get(leadingRegistrar.Url + "/status")
-		resp, err := http.Get(url) // #nosec G107
-		if err != nil {
-			log.Println("lost leading registrar status:", err)
-			leadingRegistrar = nil
-			return false
-		}
+	for {
+		if leadingRegistrar != nil {
+			resp, err := http.Get(leadingRegistrar.Url + "/status")
+			if err != nil {
+				log.Println("lost leading registrar status:", err)
+				leadingRegistrar = nil
+				continue // Skip to the next iteration of the loop
+			}
 
-		// Read from resp.Body and then close it directly after
-		bodyBytes, err := io.ReadAll(resp.Body)
-		errClose := resp.Body.Close() // Close the body directly after reading from it
-		if err != nil {
-			log.Println("\rError reading response from leading registrar:", err)
-			leadingRegistrar = nil
-			return false
+			// Read from resp.Body and then close it directly after
+			bodyBytes, err := io.ReadAll(resp.Body)
+			errClose := resp.Body.Close() // Close the body directly after reading from it
+			if err != nil {
+				log.Println("\rError reading response from leading registrar:", err)
+				leadingRegistrar = nil
+				continue // Skip to the next iteration of the loop
+			}
+			if errClose != nil {
+				log.Println("Error closing the leading registrar response body:", errClose)
+			}
+
+			if !strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
+				leadingRegistrar = nil
+				log.Println("lost previous leading registrar")
+			}
+		} else {
+			for _, cSys := range sys.CoreS {
+				core := cSys
+				if core.Name == "serviceregistrar" {
+					resp, err := http.Get(core.Url + "/status")
+					if err != nil {
+						fmt.Println("error checking service registrar status:", err)
+						continue // Skip to the next iteration of the loop
+					}
+
+					// Read from resp.Body and then close it directly after
+					bodyBytes, err := io.ReadAll(resp.Body)
+					errClose := resp.Body.Close() // Close the body directly after reading from it
+					if err != nil {
+						fmt.Println("Error reading service registrar response body:", err)
+						continue // Skip to the next iteration of the loop
+					}
+					if errClose != nil {
+						fmt.Println("Error closing service registrar response body:", errClose)
+					}
+					if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
+						leadingRegistrar = core
+						fmt.Printf("\nlead registrar found at: %s\n", leadingRegistrar.Url)
+					}
+				}
+			}
 		}
-		if errClose != nil {
-			log.Println("Error closing the leading registrar response body:", errClose)
+
+		select {
+		case <-ticker.C:
+		case <-sys.Ctx.Done():
+			return
 		}
+	}
+}
+
+func HandleLeadingRegistrar(sys *components.System, leadingRegistrarTest bool) (test int) {
 
-		if !strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
-			leadingRegistrar = nil
-			log.Println("lost previous leading registrar")
-			return false
+	var leadingRegistrar *components.CoreSystem
+	if leadingRegistrarTest == true {
+		leadingRegistrar = &components.CoreSystem{
+			Name:        "leadingregistrar",
+			Url:         "https://leadingregistrar",
+			Certificate: "",
 		}
-		return true
-	} else {
-		for _, cSys := range sys.CoreS {
-			core := cSys
-			if core.Name == "serviceregistrar" {
-				//resp, err := http.Get(core.Url + "/status")
-				resp, err := http.Get(url) // #nosec G107
-				if err != nil {
-					fmt.Println("error checking service registrar status:", err)
-					continue // Skip to the next iteration of the loop
-				}
+	}
 
-				// Read from resp.Body and then close it directly after
-				bodyBytes, err := io.ReadAll(resp.Body)
-				errClose := resp.Body.Close() // Close the body directly after reading from it
-				if err != nil {
-					fmt.Println("Error reading service registrar response body:", err)
-					continue // Skip to the next iteration of the loop
-				}
-				if errClose != nil {
-					fmt.Println("Error closing service registrar response body:", errClose)
-				}
-				if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
-					leadingRegistrar = core
-					fmt.Printf("\nlead registrar found at: %s\n", leadingRegistrar.Url)
-					return true
+	assetList := &sys.UAssets
+	for _, aResource := range *assetList {
+		servs := (*aResource).GetServices()
+		for _, service := range servs {
+			// service := (*servs)[j] // Correctly dereference the slice pointer and access the element
+			delay := 1 * time.Second
+			timer := time.NewTimer(delay)
+			for {
+				select {
+				case <-timer.C:
+					if leadingRegistrar != nil {
+						// delay = registerService(sys, aResource, service, leadingRegistrar)
+						_ = service
+						return int(0)
+					} else {
+						delay = 15
+						return int(delay)
+					}
+				case <-sys.Ctx.Done():
+					// deregisterService(leadingRegistrar, service)
+					return -1
 				}
 			}
 		}
 	}
-	return false
+	return -1
 }
 
 // registerService makes a POST or PUT request to register or register individual services
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 83b80a4..6945a7f 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -3,6 +3,9 @@ package usecases
 import (
 	//"bytes"
 	"context"
+	"sync"
+	"time"
+
 	//"encoding/json"
 	//"errors"
 	//"fmt"
@@ -38,28 +41,33 @@ func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err er
 	return t.resp, nil
 }
 
-type mockUnitAsset struct {
+type UnitAsset struct {
+	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
+	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
+	Details     map[string][]string `json:"details"` // Metadata or details about this UA
+	ServicesMap components.Services `json:"-"`
+	CervicesMap components.Cervices `json:"-"`
+	//
+	test int `json:"-"`
 }
 
-func (mua mockUnitAsset) GetName() string {
-	return "Test UnitAsset"
+func (mua *UnitAsset) GetName() string {
+	return mua.Name
 }
 
-func (mua mockUnitAsset) GetServices() components.Services {
-	return nil
+func (mua *UnitAsset) GetServices() components.Services {
+	return mua.ServicesMap
 }
 
-func (mua mockUnitAsset) GetCervices() components.Cervices {
-	return nil
+func (mua *UnitAsset) GetCervices() components.Cervices {
+	return mua.CervicesMap
 }
 
-func (mua mockUnitAsset) GetDetails() map[string][]string {
-	return map[string][]string{
-		"Details": []string{"test1", "test2"},
-	}
+func (mua *UnitAsset) GetDetails() map[string][]string {
+	return mua.Details
 }
 
-func (mua mockUnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
+func (mua *UnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
 	return
 }
 
@@ -93,6 +101,26 @@ func createTestSystem(ctx context.Context) components.System {
 		leadingRegistrar,
 		test,
 	}
+
+	setTest := &components.Service{
+		Definition:  "test",
+		SubPath:     "test",
+		Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
+		Description: "A test service",
+	}
+	ServicesMap := &components.Services{
+		setTest.SubPath: setTest,
+	}
+	mua := &UnitAsset{
+		Name:        "mockUnitAsset",
+		Details:     map[string][]string{"Test": {"Test"}},
+		ServicesMap: *ServicesMap,
+	}
+
+	sys.UAssets = make(map[string]*components.UnitAsset)
+	var muaInterface components.UnitAsset = mua
+	sys.UAssets[mua.GetName()] = &muaInterface
+
 	return sys
 }
 
@@ -109,11 +137,35 @@ func TestDiscoverLeadingRegistrar(t *testing.T) {
 	defer cancel()
 	testSys := createTestSystem(ctx)
 
-	result := DiscoverLeadingRegistrar(&testSys, testURL, false)
-	if result != true {
-		t.Errorf("Expected %t, got: %t", true, result)
+	manualTicker := 10 * time.Millisecond
+
+	var wg sync.WaitGroup
+
+	resultCh := make(chan *components.CoreSystem, 1)
+	defer close(resultCh)
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		DiscoverLeadingRegistrar(&testSys, testURL, manualTicker, true)
+	}()
+	cancel()
+	wg.Wait()
+	select {
+	case res := <-resultCh:
+		if res.Name != "serviceregistrar" {
+			t.Errorf("Expected %s, got: %s", "serviceregistrar", res.Name)
+		}
+	case <-time.After(200 * time.Millisecond):
+		t.Error("Timeout waiting for HandleLeadingRegistrar result")
 	}
 
+	/*
+		result := DiscoverLeadingRegistrar(&testSys, testURL, false)
+		if result != true {
+			t.Errorf("Expected %t, got: %t", true, result)
+		}
+	*/
+
 	/*
 		statusCode = http.StatusBadRequest
 		responseBody = "lead Service Registrar since"
@@ -123,13 +175,15 @@ func TestDiscoverLeadingRegistrar(t *testing.T) {
 		}
 	*/
 
-	statusCode = http.StatusOK
-	responseBody = "wrong response"
-	testURL = ts.URL
-	result = DiscoverLeadingRegistrar(&testSys, testURL, false)
-	if result != false {
-		t.Errorf("Expected %t, got: %t", false, result)
-	}
+	/*
+		statusCode = http.StatusOK
+		responseBody = "wrong response"
+		testURL = ts.URL
+		result = DiscoverLeadingRegistrar(&testSys, testURL, false)
+		if result != false {
+			t.Errorf("Expected %t, got: %t", false, result)
+		}
+	*/
 
 	/*
 		statusCode = http.StatusBadRequest
@@ -140,21 +194,23 @@ func TestDiscoverLeadingRegistrar(t *testing.T) {
 		}
 	*/
 
-	statusCode = http.StatusOK
-	responseBody = "lead Service Registrar since"
-	testURL = ts.URL
-	result = DiscoverLeadingRegistrar(&testSys, testURL, true)
-	if result != true {
-		t.Errorf("Expected %t, got: %t", true, result)
-	}
+	/*
+		statusCode = http.StatusOK
+		responseBody = "lead Service Registrar since"
+		testURL = ts.URL
+		result = DiscoverLeadingRegistrar(&testSys, testURL, true)
+		if result != true {
+			t.Errorf("Expected %t, got: %t", true, result)
+		}
 
-	statusCode = http.StatusOK
-	responseBody = "wrong response"
-	testURL = ts.URL
-	result = DiscoverLeadingRegistrar(&testSys, testURL, true)
-	if result != false {
-		t.Errorf("Expected %t, got: %t", false, result)
-	}
+		statusCode = http.StatusOK
+		responseBody = "wrong response"
+		testURL = ts.URL
+		result = DiscoverLeadingRegistrar(&testSys, testURL, true)
+		if result != false {
+			t.Errorf("Expected %t, got: %t", false, result)
+		}
+	*/
 
 	/*
 		statusCode = http.StatusBadRequest
@@ -172,3 +228,34 @@ func TestDiscoverLeadingRegistrar(t *testing.T) {
 		}
 	*/
 }
+
+func TestHandleLeadingRegistrar(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
+
+	result := HandleLeadingRegistrar(&testSys, false)
+	if result != 15 {
+		t.Errorf("Expected %d, got: %d", 15, result)
+	}
+
+	result = HandleLeadingRegistrar(&testSys, true)
+	if result != 0 {
+		t.Errorf("Expected %d, got: %d", 0, result)
+	}
+
+	resultCh := make(chan int)
+	go func() {
+		resultCh <- HandleLeadingRegistrar(&testSys, true)
+	}()
+	time.Sleep(50 * time.Millisecond)
+	cancel()
+	select {
+	case res := <-resultCh:
+		if res != -1 {
+			t.Errorf("Expected %d, got: %d", -1, res)
+		}
+	case <-time.After(200 * time.Millisecond):
+		t.Error("Timeout waiting for HandleLeadingRegistrar result")
+	}
+}

From 3787a3d5712abba263693d9762bbfc1221e7aaee Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Tue, 10 Jun 2025 14:11:44 +0200
Subject: [PATCH 023/186] ignores cover files and json

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index 2ee5bd8..6e3bbcf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,8 @@
 *.dll
 *.so
 *.dylib
+*.html
+*.json
 
 # Test binary, built with `go test -c`
 *.test

From dc43051d7b6146a037e716b7bf54038d9f7884e9 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 10 Jun 2025 14:26:59 +0200
Subject: [PATCH 024/186] Work in progress

---
 usecases/serviceDiscovery_test.go | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 4f68d02..89e641b 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -305,3 +305,15 @@ func TestSearch4Service(t *testing.T) {
 	}
 	cancel()
 }
+
+func TestSearch4Services(t *testing.T) {
+	return
+}
+
+func TestFillDiscoveredServices(t *testing.T) {
+	return
+}
+
+func TestExtractDiscoveryForm(t *testing.T) {
+	return
+}

From 279d4bf4b4af0bcbd78b8213d1e2926279b08708 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Tue, 10 Jun 2025 17:04:14 +0200
Subject: [PATCH 025/186] Continued with testing of registration.go,
 specifically the registerServices function

---
 usecases/registration.go      |  44 ++++++-------
 usecases/registration_test.go | 112 +++++++++++++++++++++++-----------
 2 files changed, 94 insertions(+), 62 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index 799c097..cf529d9 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -36,6 +36,8 @@ import (
 	"github.com/sdoque/mbaigo/forms"
 )
 
+/*
+
 // RegisterServices keeps track of the leading Service Registrar and keeps all services registered
 func RegisterServices(sys *components.System) {
 
@@ -136,18 +138,14 @@ func RegisterServices(sys *components.System) {
 	}
 }
 
-func DiscoverLeadingRegistrar(sys *components.System, url string, manualTicker time.Duration, leadingRegistrarTest bool) {
+*/
+
+func DiscoverLeadingRegistrar(sys *components.System, manualTicker time.Duration) *components.CoreSystem {
 	var leadingRegistrar *components.CoreSystem
-	if leadingRegistrarTest == true {
-		leadingRegistrar = &components.CoreSystem{
-			Name:        "leadingregistrar",
-			Url:         "https://leadingregistrar",
-			Certificate: "",
-		}
-	}
 	// Create a buffered channel for the pointer to the leading service registrar
 	registrarStream := make(chan *components.CoreSystem, 1)
 	defer close(registrarStream)
+	// ticker := time.NewTicker(5 * time.Second)
 	ticker := time.NewTicker(manualTicker)
 	defer ticker.Stop()
 	for {
@@ -206,48 +204,44 @@ func DiscoverLeadingRegistrar(sys *components.System, url string, manualTicker t
 		select {
 		case <-ticker.C:
 		case <-sys.Ctx.Done():
-			return
+			return leadingRegistrar
 		}
 	}
 }
 
-func HandleLeadingRegistrar(sys *components.System, leadingRegistrarTest bool) (test int) {
+func HandleLeadingRegistrar(sys *components.System, manualTicker time.Duration, leadingRegistrarTest bool) {
 
 	var leadingRegistrar *components.CoreSystem
 	if leadingRegistrarTest == true {
-		leadingRegistrar = &components.CoreSystem{
-			Name:        "leadingregistrar",
-			Url:         "https://leadingregistrar",
-			Certificate: "",
-		}
+		leadingRegistrar = sys.CoreS[1]
 	}
+	// Create a buffered channel for the pointer to the leading service registrar
+	registrarStream := make(chan *components.CoreSystem, 1)
+	defer close(registrarStream)
 
 	assetList := &sys.UAssets
 	for _, aResource := range *assetList {
 		servs := (*aResource).GetServices()
 		for _, service := range servs {
 			// service := (*servs)[j] // Correctly dereference the slice pointer and access the element
-			delay := 1 * time.Second
-			timer := time.NewTimer(delay)
+			// delay := 1 * time.Second
+			delay := manualTicker
 			for {
+				timer := time.NewTimer(delay)
 				select {
 				case <-timer.C:
 					if leadingRegistrar != nil {
-						// delay = registerService(sys, aResource, service, leadingRegistrar)
-						_ = service
-						return int(0)
+						delay = registerService(sys, aResource, service, leadingRegistrar)
 					} else {
-						delay = 15
-						return int(delay)
+						delay = 15 * time.Second
 					}
 				case <-sys.Ctx.Done():
-					// deregisterService(leadingRegistrar, service)
-					return -1
+					deregisterService(leadingRegistrar, service)
+					return
 				}
 			}
 		}
 	}
-	return -1
 }
 
 // registerService makes a POST or PUT request to register or register individual services
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 6945a7f..7c56bda 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -3,12 +3,12 @@ package usecases
 import (
 	//"bytes"
 	"context"
-	"sync"
+	//"sync"
 	"time"
 
 	//"encoding/json"
 	//"errors"
-	//"fmt"
+	"fmt"
 	//"io"
 	//"log"
 	//"net"
@@ -71,6 +71,12 @@ func (mua *UnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePat
 	return
 }
 
+type errorReader struct{}
+
+func (errorReader) Read(p []byte) (int, error) {
+	return 0, fmt.Errorf("forced read error")
+}
+
 func createTestSystem(ctx context.Context) components.System {
 	sys := components.NewSystem("testSystem", ctx)
 
@@ -82,19 +88,16 @@ func createTestSystem(ctx context.Context) components.System {
 	}
 
 	orchestrator := &components.CoreSystem{
-		Name:        "orchestrator",
-		Url:         "https://orchestrator",
-		Certificate: "",
+		Name: "orchestrator",
+		Url:  "https://orchestrator",
 	}
 	leadingRegistrar := &components.CoreSystem{
-		Name:        "serviceregistrar",
-		Url:         "https://leadingregistrar",
-		Certificate: "",
+		Name: "serviceregistrar",
+		Url:  "https://leadingregistrar",
 	}
 	test := &components.CoreSystem{
-		Name:        "test",
-		Url:         "https://test",
-		Certificate: "",
+		Name: "test",
+		Url:  "https://test",
 	}
 	sys.CoreS = []*components.CoreSystem{
 		orchestrator,
@@ -137,26 +140,61 @@ func TestDiscoverLeadingRegistrar(t *testing.T) {
 	defer cancel()
 	testSys := createTestSystem(ctx)
 
-	manualTicker := 10 * time.Millisecond
+	testSys.CoreS[1].Url = testURL
 
-	var wg sync.WaitGroup
+	manualTicker := 10 * time.Millisecond
 
 	resultCh := make(chan *components.CoreSystem, 1)
 	defer close(resultCh)
-	wg.Add(1)
 	go func() {
-		defer wg.Done()
-		DiscoverLeadingRegistrar(&testSys, testURL, manualTicker, true)
+		resultCh <- DiscoverLeadingRegistrar(&testSys, manualTicker)
 	}()
+	time.Sleep(5 * manualTicker)
 	cancel()
-	wg.Wait()
 	select {
 	case res := <-resultCh:
 		if res.Name != "serviceregistrar" {
 			t.Errorf("Expected %s, got: %s", "serviceregistrar", res.Name)
 		}
 	case <-time.After(200 * time.Millisecond):
-		t.Error("Timeout waiting for HandleLeadingRegistrar result")
+		t.Error("Timeout waiting for DiscoverLeadingRegistrar result")
+	}
+
+	statusCode = http.StatusOK
+	responseBody = "wrong response"
+	testURL = ts.URL
+	testSys.CoreS[1].Url = testURL
+	go func() {
+		resultCh <- DiscoverLeadingRegistrar(&testSys, manualTicker)
+	}()
+	time.Sleep(5 * manualTicker)
+	cancel()
+	select {
+	case res := <-resultCh:
+		if res != nil {
+			t.Errorf("Expected %s, got: %s", "leadingRegistrar be nil", res.Name)
+		}
+	case <-time.After(200 * time.Millisecond):
+		t.Error("Timeout waiting for DiscoverLeadingRegistrar result")
+	}
+
+	statusCode = http.StatusOK
+	responseBody = "lead Service Registrar since"
+	testURL = ts.URL
+	testSys.CoreS[1].Url = testURL
+	ts.Close()
+	go func() {
+		resultCh <- DiscoverLeadingRegistrar(&testSys, manualTicker)
+	}()
+	time.Sleep(5 * manualTicker)
+	cancel()
+	select {
+	case res := <-resultCh:
+		if res != nil {
+			t.Errorf("Expected %s, got: %s", "leadingRegistrar be nil since Get() error", res.Name)
+		}
+	case <-time.After(200 * time.Millisecond):
+		t.Error("Timeout waiting for DiscoverLeadingRegistrar result")
 	}
 
 	/*
@@ -230,32 +268,32 @@ func TestDiscoverLeadingRegistrar(t *testing.T) {
 }
 
 func TestHandleLeadingRegistrar(t *testing.T) {
+	statusCode := http.StatusOK
+	responseBody := "lead Service Registrar since"
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(statusCode)
+		w.Write([]byte(responseBody))
+	}))
+	defer ts.Close()
+	testURL := ts.URL
+
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	testSys := createTestSystem(ctx)
 
-	result := HandleLeadingRegistrar(&testSys, false)
-	if result != 15 {
-		t.Errorf("Expected %d, got: %d", 15, result)
-	}
+	testSys.CoreS[1].Url = testURL
 
-	result = HandleLeadingRegistrar(&testSys, true)
-	if result != 0 {
-		t.Errorf("Expected %d, got: %d", 0, result)
-	}
+	manualTicker := 10 * time.Millisecond
 
-	resultCh := make(chan int)
 	go func() {
-		resultCh <- HandleLeadingRegistrar(&testSys, true)
+		HandleLeadingRegistrar(&testSys, manualTicker, false)
 	}()
-	time.Sleep(50 * time.Millisecond)
+	time.Sleep(100 * time.Millisecond)
+	cancel()
+
+	go func() {
+		HandleLeadingRegistrar(&testSys, manualTicker, true)
+	}()
+	time.Sleep(100 * time.Millisecond)
 	cancel()
-	select {
-	case res := <-resultCh:
-		if res != -1 {
-			t.Errorf("Expected %d, got: %d", -1, res)
-		}
-	case <-time.After(200 * time.Millisecond):
-		t.Error("Timeout waiting for HandleLeadingRegistrar result")
-	}
 }

From cce999be9627b441aa7b89e10d707c8bbcbe2f6d Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 10 Jun 2025 18:34:59 +0200
Subject: [PATCH 026/186] Added tests for sendHttpReq(),
 FillDiscoveredServices(), ExtractDiscoveryForm()

---
 usecases/serviceDiscovery.go      |  47 +++----
 usecases/serviceDiscovery_test.go | 201 +++++++++++++++++++++++++-----
 2 files changed, 189 insertions(+), 59 deletions(-)

diff --git a/usecases/serviceDiscovery.go b/usecases/serviceDiscovery.go
index 25d1f8a..befd92f 100644
--- a/usecases/serviceDiscovery.go
+++ b/usecases/serviceDiscovery.go
@@ -81,8 +81,8 @@ func ExtractQuestForm(bodyBytes []byte) (rec forms.ServiceQuest_v1, err error) {
 	return
 }
 
-func sendHttpReq(method string, oURL string, jsonQF []byte, ctx context.Context) (resp *http.Response, err error) {
-	req, err := http.NewRequest(method, oURL, bytes.NewBuffer(jsonQF))
+func sendHttpReq(method string, url string, jsonQF []byte, ctx context.Context) (resp *http.Response, err error) {
+	req, err := http.NewRequest(method, url, bytes.NewBuffer(jsonQF))
 	if err != nil {
 		return nil, err
 	}
@@ -90,6 +90,9 @@ func sendHttpReq(method string, oURL string, jsonQF []byte, ctx context.Context)
 	req = req.WithContext(ctx)                         // associate the cancellable context with the request
 
 	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
 	return
 }
 
@@ -98,35 +101,21 @@ func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocat
 
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) // Create a new context, with a 2-second timeout
 	defer cancel()
+
 	// Create a new HTTP request to the Orchestrator system (for now the Service Registrar)
-	var orchestratorPointer *components.CoreSystem
-	for _, cSys := range sys.CoreS {
-		if cSys.Name == "orchestrator" {
-			orchestratorPointer = cSys
-		}
+	orchestratorPointer, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
+	if err != nil {
+		return servLocation, err
 	}
 
 	// prepare the payload to perform a service quest
-	oURL := orchestratorPointer.Url + "/squest"
+	oURL := orchestratorPointer + "/squest"
 	jsonQF, err := json.MarshalIndent(qf, "", "  ")
 	if err != nil {
-		log.Printf("problem encountered when marshalling the service quest to the Orchestrator at %s\n", oURL)
 		return servLocation, err
 	}
-	/*
-		// prepare the request
-		req, err := http.NewRequest(http.MethodPost, oURL, bytes.NewBuffer(jsonQF))
-		if err != nil {
-			return servLocation, err
-		}
-		req.Header.Set("Content-Type", "application/json") // set the Content-Type header
-		req = req.WithContext(ctx)                         // associate the cancellable context with the request
 
-		// Send the request /////////////////////////////////
-		//client := &http.Client{}
-		resp, err := http.DefaultClient.Do(req) // changed to DefaultClient to simplify testing
-	*/
-	resp, err := sendHttpReq(http.MethodPost, oURL, jsonQF, ctx) // Moved above codeblock into help function, to improve readability
+	resp, err := sendHttpReq(http.MethodPost, oURL, jsonQF, ctx)
 	if err != nil {
 		return servLocation, err
 	}
@@ -163,17 +152,15 @@ func Search4Services(cer *components.Cervice, sys *components.System) (err error
 	}
 
 	// Search for an Orchestrator system within the local cloud
-	var orchestratorPointer *components.CoreSystem
-	for _, cSys := range sys.CoreS {
-		if cSys.Name == "orchestrator" {
-			orchestratorPointer = cSys
-		}
+	orchestratorPointer, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
+	if err != nil {
+		return err
 	}
-	if orchestratorPointer == nil {
+	if orchestratorPointer == "" {
 		err = errors.New("failed to locate an Orchestrator")
 		return err
 	}
-	oURL := orchestratorPointer.Url + "/squest"
+	oURL := orchestratorPointer + "/squest"
 
 	// Prepare the request to the Orchestrator
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) // Create a new context, with a 2-second timeout
@@ -249,7 +236,7 @@ func ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err err
 	}
 	formVersion, ok := jsonData["version"].(string)
 	if !ok {
-		log.Printf("Error: 'version' key not found in JSON data")
+		err = errors.New("Error: 'version' key not found in JSON data")
 		return
 	}
 	switch formVersion {
diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 89e641b..d555d29 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -76,6 +76,7 @@ func (mua mockUnitAsset) Serving(w http.ResponseWriter, r *http.Request, service
 }
 
 // Tests the output from ServQuestForms() to ensure expected outcome
+
 func TestServQuestForms(t *testing.T) {
 	expectedForms := []string{"ServiceQuest_v1", "ServicePoint_v1"}
 	lst := ServQuestForms()
@@ -140,6 +141,7 @@ type testBodyHasProtocol struct {
 type testBodyHasVersion struct {
 	Version string `json:"version"`
 }
+
 type testBodyNoVersion struct{}
 
 func TestExtractQuestForm(t *testing.T) {
@@ -215,18 +217,60 @@ func (errReader) Close() error {
 
 var brokenUrl = string([]byte{0x7f})
 
-/*
-type ServiceQuest_v1 struct {
-	SysId             int                 `json:"systemId"`
-	RequesterName     string              `json:"requesterName"`
-	ServiceDefinition string              `json:"serrviceDefinition"`
-	Protocol          string              `json:"protocol"`
-	Details           map[string][]string `json:"details"`
-	Version           string              `json:"version"`
-	Break             any                 `json:"break"`
+// sendHttpReq(method string, url string, jsonQF []byte, ctx context.Context) (resp *http.Response, err error)
+func TestSendHttpReq(t *testing.T) {
+	// Good case: everything passes
+	resp := &http.Response{
+		Status:     "200 OK",
+		StatusCode: 200,
+		Body:       io.NopCloser(strings.NewReader(string("test body"))),
+	}
+	newMockTransport(resp, false, nil)
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	var qForm forms.ServiceQuest_v1
+	qForm.NewForm()
+	jsonQF, err := json.MarshalIndent(qForm, "", "  ")
+	if err != nil {
+		t.Errorf("Error occured while Marshalling in test: %v", err)
+	}
+	_, err = sendHttpReq(http.MethodPost, "https://test", jsonQF, ctx)
+	if err != nil {
+		t.Errorf("Expected no errors, got: %v", err)
+	}
+	cancel()
+
+	// Bad case: url broken, cant make request
+	ctx, cancel = context.WithCancel(context.Background())
+	qForm.NewForm()
+	_, err = sendHttpReq(http.MethodPost, brokenUrl, jsonQF, ctx)
+	if err == nil {
+		t.Errorf("Expected errors while sending http request")
+	}
+	cancel()
+
+	// Bad case: response returns error
+	newMockTransport(resp, true, errHTTP)
+	ctx, cancel = context.WithCancel(context.Background())
+	qForm.NewForm()
+	_, err = sendHttpReq(http.MethodPost, "https://test", jsonQF, ctx)
+	if err == nil {
+		t.Errorf("Expected errors while sending http request")
+	}
+	cancel()
 }
-*/
 
+/*
+	type ServiceQuest_v1 struct {
+		SysId             int                 `json:"systemId"`
+		RequesterName     string              `json:"requesterName"`
+		ServiceDefinition string              `json:"serrviceDefinition"`
+		Protocol          string              `json:"protocol"`
+		Details           map[string][]string `json:"details"`
+		Version           string              `json:"version"`
+		Break             any                 `json:"break"`
+	}
+*/
 func TestSearch4Service(t *testing.T) {
 	// Best case, everything pass
 	f := createServicePointTestForm()
@@ -244,6 +288,7 @@ func TestSearch4Service(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	testSys := createTestSystem(ctx, false)
 	var qForm forms.ServiceQuest_v1
+
 	serviceForm, err := Search4Service(qForm, &testSys)
 	if err != nil {
 		t.Errorf("Expected no errors, got: %v", err)
@@ -251,34 +296,26 @@ func TestSearch4Service(t *testing.T) {
 	if serviceForm.ServLocation != f.ServLocation {
 		t.Errorf("Expected %s, got: %s", f.ServLocation, serviceForm.ServLocation)
 	}
+
 	cancel()
 
 	// Error at "prepare the payload to perform a service quest"
 	// Untested because I found no way of breaking json.Marshal, without making big changes to the form
 
-	// "prepare the request" and "Send the request" codeblocks have been moved into a helpfunction, still gets tested though
-	// Error at "prepare the request" part of sendHttpReq()
-	newMockTransport(resp, false, nil)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, true)
-	qForm.NewForm()
-	serviceForm, err = Search4Service(qForm, &testSys)
-	if err == nil {
-		t.Errorf("Expected error on first marshal, got none")
-	}
-	cancel()
-
-	// Error at "Send the request" part of sendHttpReq()
+	// Error while getting core system url
 	newMockTransport(resp, true, errHTTP)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
 	qForm.NewForm()
-	serviceForm, err = Search4Service(qForm, &testSys)
+	_, err = Search4Service(qForm, &testSys)
 	if err == nil {
-		t.Errorf("Expected error on first marshal, got none")
+		t.Errorf("Expected error at GetRunningCoreSystemURL()")
 	}
 	cancel()
 
+	// Error at sendHttpRequest
+	// Can't be tested
+
 	// Error at "Read the response", io.ReadAll()
 	f = createServicePointTestForm()
 	resp.Body = errReader(0)
@@ -288,7 +325,7 @@ func TestSearch4Service(t *testing.T) {
 	qForm.NewForm()
 	serviceForm, err = Search4Service(qForm, &testSys)
 	if err == nil {
-		t.Errorf("Expected error on first marshal, got none")
+		t.Errorf("Expected error")
 	}
 	cancel()
 
@@ -301,19 +338,125 @@ func TestSearch4Service(t *testing.T) {
 	qForm.NewForm()
 	serviceForm, err = Search4Service(qForm, &testSys)
 	if err == nil {
-		t.Errorf("Expected error on first marshal, got none")
+		t.Errorf("Expected error")
 	}
 	cancel()
+
 }
 
 func TestSearch4Services(t *testing.T) {
 	return
 }
 
-func TestFillDiscoveredServices(t *testing.T) {
+/*
+   Id                int                 `json:"registryID"`
+   ServiceDefinition string              `json:"definition"`
+   SystemName        string              `json:"systemName"`
+   ServiceNode       string              `json:"serviceNode"`
+   IPAddresses       []string            `json:"ipAddresses"`
+   ProtoPort         map[string]int      `json:"protoPort"`
+   Details           map[string][]string `json:"details"`
+   Certificate       string              `json:"certificate"`
+   SubPath           string              `json:"subpath"`
+   RegLife           int                 `json:"registrationLife"`
+   Version           string              `json:"version"`
+   Created           string              `json:"created"`
+   Updated           string              `json:"updated"`
+   EndOfValidity     string              `json:"endOfValidity"`
+   SubscribeAble     bool                `json:"subscribeAble"`
+   ACost             float64             `json:"activityCost"`
+   CUnit             string              `json:"costUnit"`
+*/
+
+func createTestServiceRecord(number int) (f forms.ServiceRecord_v1) {
+	f.Id = number
+	f.ServiceDefinition = fmt.Sprintf("testDefinition%d", number)
+	f.SystemName = fmt.Sprintf("testSystem%d", number)
+	f.ServiceNode = fmt.Sprintf("test%d", number)
+	f.IPAddresses = []string{fmt.Sprintf("test%d", number), fmt.Sprintf("test%d", number+1)}
+	f.ProtoPort = map[string]int{"test": 1}
+	f.Details = map[string][]string{"Details": {fmt.Sprintf("Detail%d", number), fmt.Sprintf("Detail%d", number+1)}}
+	f.Certificate = fmt.Sprintf("Certificate%d", number)
+	f.SubPath = fmt.Sprintf("Subpath%d", number)
+	f.RegLife = number
+	f.Version = "ServiceRecord_v1"
+	f.Created = fmt.Sprintf("Created%d", number)
+	f.Updated = fmt.Sprintf("Updated%d", number)
+	f.EndOfValidity = fmt.Sprintf("EoV%d", number)
+	f.SubscribeAble = true
+	f.ACost = float64(number)
+	f.CUnit = fmt.Sprintf("CUnit%d", number)
 	return
 }
 
+// FillDiscoveredServices(dsList []forms.ServiceRecord_v1, version string) (f forms.Form, err error)
+func TestFillDiscoveredServices(t *testing.T) {
+	// Create a bunch of service records contained in a list
+	dsList := []forms.ServiceRecord_v1{}
+	for i := range 10 {
+		record := createTestServiceRecord(i)
+		dsList = append(dsList, record)
+	}
+	versionList := []string{"ServiceRecordList_v1", "default"}
+	for _, version := range versionList {
+		_, err := FillDiscoveredServices(dsList, version)
+		if version != "ServiceRecordList_v1" {
+			if err == nil {
+				t.Errorf("Expected error in default case")
+			}
+		} else {
+			if err != nil {
+				t.Errorf("Unexpected error during testing: %v", err)
+			}
+		}
+	}
+}
+
+// ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err error)
 func TestExtractDiscoveryForm(t *testing.T) {
-	return
+	// Best case: everything passes
+	spForm := createServicePointTestForm()
+	data, err := json.Marshal(spForm)
+	if err != nil {
+		t.Errorf("Error occured while marshaling the test form")
+	}
+	//form version: forms.ServicePoint_v1 expected
+	form, err := ExtractDiscoveryForm(data)
+	if err != nil {
+		t.Errorf("Expected no errors")
+	}
+	if form.ServLocation != "TestService" {
+		t.Errorf("Expected service location: %s, got %s", "TestService", form.ServLocation)
+	}
+	// Bad case: wrong form version
+	spForm.Version = ""
+	data, err = json.Marshal(spForm)
+	if err != nil {
+		t.Errorf("Error occured while marshaling the test form")
+	}
+	form, err = ExtractDiscoveryForm(data)
+	if err == nil {
+		t.Errorf("Expected error because of wrong form version")
+	}
+
+	// Bad case: error when unmarshalling body
+	data, err = json.Marshal("Test")
+	if err != nil {
+		t.Errorf("Error when marshalling in test")
+	}
+	form, err = ExtractDiscoveryForm(data)
+	if err == nil {
+		t.Errorf("Expected errors for broken unmarshal")
+	}
+
+	// Bad case: error when unmarshalling body
+	var emptyForm forms.Form
+	data, err = json.Marshal(emptyForm)
+	if err != nil {
+		t.Errorf("Error when marshalling in test")
+	}
+	form, err = ExtractDiscoveryForm(data)
+	if err == nil {
+		t.Errorf("Expected errors for missing form")
+	}
 }

From b6d69df6a4ae4f808deb12610c2007a6884e5f02 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 10 Jun 2025 18:38:13 +0200
Subject: [PATCH 027/186] Fixed spelling error

---
 usecases/serviceDiscovery_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index d555d29..071b905 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -232,7 +232,7 @@ func TestSendHttpReq(t *testing.T) {
 	qForm.NewForm()
 	jsonQF, err := json.MarshalIndent(qForm, "", "  ")
 	if err != nil {
-		t.Errorf("Error occured while Marshalling in test: %v", err)
+		t.Errorf("Error occurred while Marshalling in test: %v", err)
 	}
 	_, err = sendHttpReq(http.MethodPost, "https://test", jsonQF, ctx)
 	if err != nil {
@@ -418,7 +418,7 @@ func TestExtractDiscoveryForm(t *testing.T) {
 	spForm := createServicePointTestForm()
 	data, err := json.Marshal(spForm)
 	if err != nil {
-		t.Errorf("Error occured while marshaling the test form")
+		t.Errorf("Error occurred while marshaling the test form")
 	}
 	//form version: forms.ServicePoint_v1 expected
 	form, err := ExtractDiscoveryForm(data)
@@ -432,7 +432,7 @@ func TestExtractDiscoveryForm(t *testing.T) {
 	spForm.Version = ""
 	data, err = json.Marshal(spForm)
 	if err != nil {
-		t.Errorf("Error occured while marshaling the test form")
+		t.Errorf("Error occurred while marshaling the test form")
 	}
 	form, err = ExtractDiscoveryForm(data)
 	if err == nil {

From f24b87d9e2f6a70c98677e6adb7c969afe0429d6 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Wed, 11 Jun 2025 16:17:38 +0200
Subject: [PATCH 028/186] Continued testing of registration.go,
 ServiceRegistrationFormsList, DeepCopyMap, ServiceRegistrationForm and
 DeregisterService fully tested. Almost done with testing of RegisterService.

---
 usecases/registration.go      |  41 +++--
 usecases/registration_test.go | 319 +++++++++++++++++++++++++++++++++-
 2 files changed, 335 insertions(+), 25 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index cf529d9..81b88b7 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -231,12 +231,15 @@ func HandleLeadingRegistrar(sys *components.System, manualTicker time.Duration,
 				select {
 				case <-timer.C:
 					if leadingRegistrar != nil {
-						delay = registerService(sys, aResource, service, leadingRegistrar)
+						delay = RegisterService(sys, aResource, service, leadingRegistrar)
 					} else {
 						delay = 15 * time.Second
 					}
 				case <-sys.Ctx.Done():
-					deregisterService(leadingRegistrar, service)
+					err := DeregisterService(leadingRegistrar, service)
+					if err != nil {
+						fmt.Println("Something went wrong with deregistration of service:", err)
+					}
 					return
 				}
 			}
@@ -245,11 +248,11 @@ func HandleLeadingRegistrar(sys *components.System, manualTicker time.Duration,
 }
 
 // registerService makes a POST or PUT request to register or register individual services
-func registerService(sys *components.System, ua *components.UnitAsset, serv *components.Service, registrar *components.CoreSystem) (delay time.Duration) {
+func RegisterService(sys *components.System, ua *components.UnitAsset, serv *components.Service, registrar *components.CoreSystem) (delay time.Duration) {
 
 	delay = 15 * time.Second
 	// Prepare request
-	reqPayload, err := serviceRegistrationForm(sys, ua, serv, "ServiceRecord_v1")
+	reqPayload, err := ServiceRegistrationForm(sys, ua, serv, "ServiceRecord_v1")
 	if err != nil {
 		log.Println("Registration marshall error, ", err)
 		return
@@ -271,8 +274,9 @@ func registerService(sys *components.System, ua *components.UnitAsset, serv *com
 		}
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
-	client := &http.Client{Timeout: time.Second * 5}
-	resp, err := client.Do(req) // execute the request and get the reply
+	// client := &http.Client{Timeout: time.Second * 5}
+
+	resp, err := http.DefaultClient.Do(req) // execute the request and get the reply
 	if err != nil {
 		switch err := err.(type) {
 		case net.Error:
@@ -327,30 +331,30 @@ func registerService(sys *components.System, ua *components.UnitAsset, serv *com
 }
 
 // deregisterService deletes a service from the database based on its service id
-func deregisterService(registrar *components.CoreSystem, serv *components.Service) {
+func DeregisterService(registrar *components.CoreSystem, serv *components.Service) error {
 	if registrar == nil {
-		return // there is no need to deregister if there is no leading registrar
+		return nil // there is no need to deregister if there is no leading registrar
 	}
-	client := &http.Client{}
+	// client := &http.Client{}
 	deRegServURL := registrar.Url + "/unregister/" + strconv.Itoa(serv.ID)
-	fmt.Printf("Trying to unregiseter %s\n", deRegServURL)
+	fmt.Printf("Trying to unregister %s\n", deRegServURL)
 	req, err := http.NewRequest("DELETE", deRegServURL, nil) // create a new request using http
 	if err != nil {
-		log.Println(err)
-		return
+		return err
 	}
-	resp, err := client.Do(req) // make the request
+	resp, err := http.DefaultClient.Do(req)
+	// resp, err := client.Do(req) // make the request
 	if err != nil {
-		log.Println(err)
-		return
+		return err
 	}
 	defer resp.Body.Close()
 	fmt.Printf("service %s deleted from the service registrar with HTTP Response Status: %d, %s\n", serv.Definition, resp.StatusCode, http.StatusText(resp.StatusCode))
+	return nil
 }
 
 // serviceRegistrationForm returns a json data byte array with the data of the service to be registered
 // in the form of choice [Sending @ Application system]
-func serviceRegistrationForm(sys *components.System, ua *components.UnitAsset, serv *components.Service, version string) (payload []byte, err error) {
+func ServiceRegistrationForm(sys *components.System, ua *components.UnitAsset, serv *components.Service, version string) (payload []byte, err error) {
 	var f forms.Form
 	switch version {
 	case "ServiceRecord_v1":
@@ -368,7 +372,7 @@ func serviceRegistrationForm(sys *components.System, ua *components.UnitAsset, s
 				sr.ProtoPort[key] = port
 			}
 		}
-		sr.Details = deepCopyMap((*ua).GetDetails())
+		sr.Details = DeepCopyMap((*ua).GetDetails())
 		for key, valueSlice := range serv.Details {
 			sr.Details[key] = append(sr.Details[key], valueSlice...)
 		}
@@ -390,7 +394,7 @@ func serviceRegistrationForm(sys *components.System, ua *components.UnitAsset, s
 }
 
 // deepCopyMap is necessary to prevent adding values to the original map at every re-registration
-func deepCopyMap(m map[string][]string) map[string][]string {
+func DeepCopyMap(m map[string][]string) map[string][]string {
 	newMap := make(map[string][]string)
 	for k, v := range m {
 		newValue := make([]string, len(v))
@@ -400,6 +404,7 @@ func deepCopyMap(m map[string][]string) map[string][]string {
 	return newMap
 }
 
+// TODO: Research if this function is even needed
 // ServiceRegistrationFormsList returns the list of forms that the service registration handles
 func ServiceRegistrationFormsList() []string {
 	return []string{"ServiceRecord_v1"}
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 7c56bda..43d6a3b 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -3,6 +3,10 @@ package usecases
 import (
 	//"bytes"
 	"context"
+	"encoding/json"
+	"io"
+	"strings"
+
 	//"sync"
 	"time"
 
@@ -19,28 +23,53 @@ import (
 	//"strings"
 	"testing"
 	//"time"
+	"reflect"
 
 	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/forms"
 	//"github.com/sdoque/mbaigo/forms"
 )
 
 type mockTransport struct {
-	resp *http.Response
+	returnError bool
+	resp        *http.Response
+	hits        map[string]int
+	err         error
 }
 
-func newMockTransport(resp *http.Response) mockTransport {
+func newMockTransport(resp *http.Response, retErr bool, err error) mockTransport {
 	t := mockTransport{
-		resp: resp,
+		returnError: retErr,
+		resp:        resp,
+		err:         err,
 	}
 	http.DefaultClient.Transport = t
 	return t
 }
 
 func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	if t.err != nil {
+		return nil, t.err
+	}
+	if t.returnError != false {
+		req.GetBody = func() (io.ReadCloser, error) {
+			return nil, errHTTP
+		}
+	}
 	t.resp.Request = req
 	return t.resp, nil
 }
 
+type timeoutError struct{}
+
+func (timeoutError) Error() string   { return "timeout" }
+func (timeoutError) Timeout() bool   { return true }
+func (timeoutError) Temporary() bool { return true }
+
+var errHTTP error = fmt.Errorf("bad http request")
+
+var brokenUrl = string([]byte{0x7f})
+
 type UnitAsset struct {
 	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
 	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
@@ -51,6 +80,26 @@ type UnitAsset struct {
 	test int `json:"-"`
 }
 
+type ServiceRecord_v1 struct {
+	Id                int                 `json:"registryID"`
+	ServiceDefinition string              `json:"definition"`
+	SystemName        string              `json:"systemName"`
+	ServiceNode       string              `json:"serviceNode"`
+	IPAddresses       []string            `json:"ipAddresses"`
+	ProtoPort         map[string]int      `json:"protoPort"`
+	Details           map[string][]string `json:"details"`
+	Certificate       string              `json:"certificate"`
+	SubPath           string              `json:"subpath"`
+	RegLife           int                 `json:"registrationLife"`
+	Version           string              `json:"version"`
+	Created           string              `json:"created"`
+	Updated           string              `json:"updated"`
+	EndOfValidity     string              `json:"endOfValidity"`
+	SubscribeAble     bool                `json:"subscribeAble"`
+	ACost             float64             `json:"activityCost"`
+	CUnit             string              `json:"costUnit"`
+}
+
 func (mua *UnitAsset) GetName() string {
 	return mua.Name
 }
@@ -106,10 +155,14 @@ func createTestSystem(ctx context.Context) components.System {
 	}
 
 	setTest := &components.Service{
-		Definition:  "test",
-		SubPath:     "test",
-		Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
-		Description: "A test service",
+		ID:            1,
+		Definition:    "test",
+		SubPath:       "test",
+		Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+		Description:   "A test service",
+		RegPeriod:     45,
+		RegTimestamp:  "now",
+		RegExpiration: "45",
 	}
 	ServicesMap := &components.Services{
 		setTest.SubPath: setTest,
@@ -267,6 +320,7 @@ func TestDiscoverLeadingRegistrar(t *testing.T) {
 	*/
 }
 
+/*
 func TestHandleLeadingRegistrar(t *testing.T) {
 	statusCode := http.StatusOK
 	responseBody := "lead Service Registrar since"
@@ -297,3 +351,254 @@ func TestHandleLeadingRegistrar(t *testing.T) {
 	time.Sleep(100 * time.Millisecond)
 	cancel()
 }
+*/
+
+func TestDeepCopyMap(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
+	// Use the correct key to access the map; here we use "mockUnitAsset" as set in createTestSystem
+	mua := testSys.UAssets["mockUnitAsset"]
+	original := (*mua).GetDetails()
+	test := DeepCopyMap((*mua).GetDetails())
+
+	if !reflect.DeepEqual(original, test) {
+		t.Errorf("Expected deep copied map to be equal to original, Expected: %v, got: %v", original, test)
+	}
+
+	original["Test"][0] = "changed original"
+	if reflect.DeepEqual(original, test) {
+		t.Errorf("Deep copy failed, changes in original affected the deep copied map. Expected: %v, got %v", original, test)
+	}
+	original["Test"][0] = "test"
+
+	test["Test"][0] = "changed deep copy"
+	if reflect.DeepEqual(original, test) {
+		t.Errorf("Deep copy failed, changes in deep copied map affected the original. Expected: %v, got %v", original, test)
+	}
+}
+
+func TestServiceRegistrationForm(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
+	mua := testSys.UAssets["mockUnitAsset"]
+	serv := (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"]
+	version := "ServiceRecord_v1"
+
+	payload, err := ServiceRegistrationForm(&testSys, mua, serv, version)
+
+	if err != nil {
+		t.Fatalf("The Service Record version was wrong.")
+	}
+
+	var sr forms.ServiceRecord_v1
+	if err := json.Unmarshal(payload, &sr); err != nil {
+		t.Fatalf("Invalid JSON: %v", err)
+	}
+
+	// Set the first part to your Hosts name
+	expectedNode := "Gabriel-HP_testSystem_mockUnitAsset_test"
+	if sr.ServiceNode != expectedNode {
+		t.Errorf("Expected ServiceNode %q, got: %q", expectedNode, sr.ServiceNode)
+	}
+
+	if len(sr.ProtoPort) != 1 {
+		t.Errorf("Expected: one proto port (excluding 0s), got: %v", sr.ProtoPort)
+	}
+
+	if v, ok := sr.Details["Test"]; !ok || len(v) != 1 {
+		t.Errorf("Missing or incorrect unit asset details. Expected: %v, got: %v", (*mua).GetDetails(), v)
+	}
+
+	if v, ok := sr.Details["Forms"]; !ok || len(v) != 1 {
+		t.Errorf("Missing or incorrect unit asset details. Expected: %v, got: %v", (*serv).Details, v)
+	}
+
+	version = "UnknownVersion"
+	_, err = ServiceRegistrationForm(&testSys, mua, serv, version)
+	if err == nil {
+		t.Fatal("expected error for unsupported version, got nil")
+	}
+	if err.Error() != "unsupported service registration form version" {
+		t.Errorf("Expected error: unsupported service registration form version, got: %v", err)
+	}
+
+	(*testSys.UAssets["mockUnitAsset"]).GetServices()["test"].RegPeriod = 0
+	version = "ServiceRecord_v1"
+	payload, err = ServiceRegistrationForm(&testSys, mua, serv, version)
+	if err != nil {
+		t.Fatalf("The Service Record version was wrong.")
+	}
+
+	if err := json.Unmarshal(payload, &sr); err != nil {
+		t.Fatalf("Invalid JSON: %v", err)
+	}
+	if sr.RegLife != 30 {
+		t.Errorf("Expected RegLife: 30, got: %d", sr.RegLife)
+	}
+}
+
+func TestDeregisterService(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
+
+	var registrar *components.CoreSystem
+	serv := (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"]
+
+	resp := &http.Response{
+		Status:     "200 OK",
+		StatusCode: 200,
+		Body:       io.NopCloser(strings.NewReader(string("test body"))),
+	}
+	newMockTransport(resp, false, nil)
+
+	err := DeregisterService(registrar, serv)
+	if err != nil {
+		t.Errorf("Expected error: %v, got: %v", nil, err)
+	}
+
+	registrar = testSys.CoreS[1]
+
+	err = DeregisterService(registrar, serv)
+	if err != nil {
+		t.Errorf("Expected error: %v, got: %v", nil, err)
+	}
+
+	// bad case: response body error
+	newMockTransport(resp, true, errHTTP)
+	err = DeregisterService(registrar, serv)
+	if err == nil {
+		t.Errorf("Expected error while sending http request")
+	}
+
+	// bad case: URL broken
+	newMockTransport(resp, false, nil)
+	registrar.Url = brokenUrl
+	err = DeregisterService(registrar, serv)
+	if err == nil {
+		t.Errorf("Expected error while creating http request")
+	}
+}
+
+func TestServiceRegistrationFormList(t *testing.T) {
+	list := []string{
+		"ServiceRecord_v1",
+	}
+	test := ServiceRegistrationFormsList()
+	if !reflect.DeepEqual(list, test) {
+		t.Errorf("Expected lists to be equal. Expected: %v, got: %v", list, test)
+	}
+}
+
+func TestRegisterService(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
+	mua := testSys.UAssets["mockUnitAsset"]
+	serv := (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"]
+	registrar := testSys.CoreS[1]
+
+	payload, err := ServiceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
+
+	if err != nil {
+		t.Fatalf("The Service Record version was wrong.")
+	}
+
+	var sr forms.ServiceRecord_v1
+	if err := json.Unmarshal(payload, &sr); err != nil {
+		t.Fatalf("Invalid JSON: %v", err)
+	}
+
+	sr.EndOfValidity = time.Now().Format(time.RFC3339)
+
+	fakeBody, err := json.Marshal(sr)
+	if err != nil {
+		t.Errorf("Fail Marshal at start of test")
+	}
+
+	// Good case
+	resp := &http.Response{
+		Status:     "200 OK",
+		StatusCode: 200,
+		Header:     http.Header{"Content-Type": []string{"application/json"}},
+		Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+	}
+	newMockTransport(resp, false, nil)
+
+	test := RegisterService(&testSys, mua, serv, registrar)
+	if int(test.Seconds()) > 0 {
+		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
+	}
+	fmt.Println("Delay is: ", int(test.Seconds()))
+
+	// Bad case: when NewRequest with PUT method fails:
+	newMockTransport(resp, false, nil)
+	registrar.Url = brokenUrl
+	test = RegisterService(&testSys, mua, serv, registrar)
+	if int(test.Seconds()) != 15 {
+		t.Errorf("Expected the delay to be 15 since NewRequest with PUT method should have failed, got: %d", int(test.Seconds()))
+	}
+	fmt.Println("Delay is: ", int(test.Seconds()))
+
+	// Good case when making POST instead
+	registrar.Url = "https://leadingregistrar"
+	serv.ID = 0
+
+	payload, err = ServiceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
+
+	if err != nil {
+		t.Fatalf("The Service Record version was wrong.")
+	}
+
+	if err := json.Unmarshal(payload, &sr); err != nil {
+		t.Fatalf("Invalid JSON: %v", err)
+	}
+
+	sr.EndOfValidity = time.Now().Format(time.RFC3339)
+
+	fakeBody, err = json.Marshal(sr)
+	if err != nil {
+		t.Errorf("Fail Marshal at start of test")
+	}
+	resp = &http.Response{
+		Status:     "200 OK",
+		StatusCode: 200,
+		Header:     http.Header{"Content-Type": []string{"application/json"}},
+		Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+	}
+	newMockTransport(resp, false, nil)
+	test = RegisterService(&testSys, mua, serv, registrar)
+	if int(test.Seconds()) > 0 {
+		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
+	}
+	fmt.Println("Delay is: ", int(test.Seconds()))
+
+	// Bad case: when NewRequest with POST method fails:
+	newMockTransport(resp, false, nil)
+	registrar.Url = brokenUrl
+	test = RegisterService(&testSys, mua, serv, registrar)
+	if int(test.Seconds()) != 15 {
+		t.Errorf("Expected the delay to be 15 since NewRequest with POST method should have failed, got: %d", int(test.Seconds()))
+	}
+	fmt.Println("Delay is: ", int(test.Seconds()))
+
+	// Bad case: when http.DefaultClient.Do() fails with a err.Timeout()
+	registrar.Url = "https://leadingregistrar"
+	timeoutErr := timeoutError{}
+	newMockTransport(resp, true, timeoutErr)
+	test = RegisterService(&testSys, mua, serv, registrar)
+	if int(test.Seconds()) != 15 {
+		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
+	}
+	fmt.Println("Delay is :", int(test.Seconds()))
+
+	// Bad case: when http.DefaultClient.Do() fails but not with a err.Timeout()
+	newMockTransport(resp, true, errHTTP)
+	test = RegisterService(&testSys, mua, serv, registrar)
+	if int(test.Seconds()) != 15 {
+		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
+	}
+	fmt.Println("Delay is :", int(test.Seconds()))
+}

From c73628d9e3a7d5a49888322d6ff75d71a0a6cc7f Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Thu, 12 Jun 2025 08:38:45 +0200
Subject: [PATCH 029/186] Made generalization of test of
 ServiceRegistrationForm to work on all machines

---
 usecases/registration_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 43d6a3b..b172144 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -398,7 +398,7 @@ func TestServiceRegistrationForm(t *testing.T) {
 	}
 
 	// Set the first part to your Hosts name
-	expectedNode := "Gabriel-HP_testSystem_mockUnitAsset_test"
+	expectedNode := testSys.Host.Name + "_" + testSys.Name + "_" + (*testSys.UAssets["mockUnitAsset"]).GetName() + "_" + (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"].Definition
 	if sr.ServiceNode != expectedNode {
 		t.Errorf("Expected ServiceNode %q, got: %q", expectedNode, sr.ServiceNode)
 	}

From fd7b37d48fcf21abefbb1406aa181922db4acfcb Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 12 Jun 2025 11:23:22 +0200
Subject: [PATCH 030/186] Added tests for Search4Service() and
 Search4Services()

---
 usecases/serviceDiscovery.go      |  19 +-
 usecases/serviceDiscovery_test.go | 298 +++++++++++++++++++++---------
 2 files changed, 214 insertions(+), 103 deletions(-)

diff --git a/usecases/serviceDiscovery.go b/usecases/serviceDiscovery.go
index befd92f..daa8cf8 100644
--- a/usecases/serviceDiscovery.go
+++ b/usecases/serviceDiscovery.go
@@ -81,8 +81,8 @@ func ExtractQuestForm(bodyBytes []byte) (rec forms.ServiceQuest_v1, err error) {
 	return
 }
 
-func sendHttpReq(method string, url string, jsonQF []byte, ctx context.Context) (resp *http.Response, err error) {
-	req, err := http.NewRequest(method, url, bytes.NewBuffer(jsonQF))
+func sendHttpReq(method string, url string, data []byte, ctx context.Context) (resp *http.Response, err error) {
+	req, err := http.NewRequest(method, url, bytes.NewBuffer(data))
 	if err != nil {
 		return nil, err
 	}
@@ -165,20 +165,11 @@ func Search4Services(cer *components.Cervice, sys *components.System) (err error
 	// Prepare the request to the Orchestrator
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) // Create a new context, with a 2-second timeout
 	defer cancel()
-	req, err := http.NewRequest(http.MethodPost, oURL, bytes.NewBuffer(qf))
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Content-Type", "application/json") // set the Content-Type header
-	req = req.WithContext(ctx)                         // associate the cancellable context with the request
 
-	// Send the request to the Orchestrator /////////////////////////////////
-	client := &http.Client{}
-	resp, err := client.Do(req)
+	resp, err := sendHttpReq(http.MethodPost, oURL, qf, ctx)
 	if err != nil {
-		return err
+		return
 	}
-
 	defer resp.Body.Close()
 
 	// Check if the status code indicates an error (anything outside the 200–299 range)
@@ -236,7 +227,7 @@ func ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err err
 	}
 	formVersion, ok := jsonData["version"].(string)
 	if !ok {
-		err = errors.New("Error: 'version' key not found in JSON data")
+		err = errors.New("error: 'version' key not found in JSON data")
 		return
 	}
 	switch formVersion {
diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 071b905..ceebc46 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -16,17 +16,16 @@ import (
 // mockTransport is used for replacing the default network Transport (used by
 // http.DefaultClient) and it will intercept network requests.
 type mockTransport struct {
-	returnError bool
-	resp        *http.Response
-	hits        map[string]int
-	err         error
+	resp *http.Response
+	hits int
+	err  error
 }
 
-func newMockTransport(resp *http.Response, retErr bool, err error) mockTransport {
-	t := mockTransport{
-		returnError: retErr,
-		resp:        resp,
-		err:         err,
+func newMockTransport(resp *http.Response, v int, err error) *mockTransport {
+	t := &mockTransport{
+		resp: resp,
+		hits: v,
+		err:  err,
 	}
 	// Hijack the default http client so no actual http requests are sent over the network
 	http.DefaultClient.Transport = t
@@ -34,47 +33,20 @@ func newMockTransport(resp *http.Response, retErr bool, err error) mockTransport
 }
 
 // RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
-// It prevents the request from being sent over the network and count how many times
-// a domain was requested.
-func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-	if t.err != nil {
+// It prevents the request from being sent over the network, and count how many times
+// a http request was sent
+func (t *mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	t.hits -= 1
+	//log.Printf("hits: %d", t.hits)
+	if t.hits == 0 {
 		return nil, t.err
 	}
-	if t.returnError != false {
-		req.GetBody = func() (io.ReadCloser, error) {
-			return nil, errHTTP
-		}
-	}
 	t.resp.Request = req
 	return t.resp, nil
 }
 
 var errHTTP error = fmt.Errorf("bad http request")
 
-type mockUnitAsset struct {
-}
-
-func (mua mockUnitAsset) GetName() string {
-	return "Test UnitAsset"
-}
-
-func (mua mockUnitAsset) GetServices() components.Services {
-	return nil
-}
-func (mua mockUnitAsset) GetCervices() components.Cervices {
-	return nil
-}
-
-func (mua mockUnitAsset) GetDetails() map[string][]string {
-	return map[string][]string{
-		"Details": []string{"test1", "test2"},
-	}
-}
-
-func (mua mockUnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
-	return
-}
-
 // Tests the output from ServQuestForms() to ensure expected outcome
 
 func TestServQuestForms(t *testing.T) {
@@ -88,6 +60,32 @@ func TestServQuestForms(t *testing.T) {
 	}
 }
 
+type UnitAsset struct {
+	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
+	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
+	Details     map[string][]string `json:"details"` // Metadata or details about this UA
+	ServicesMap components.Services `json:"-"`
+	CervicesMap components.Cervices `json:"-"`
+}
+
+func (mua UnitAsset) GetName() string {
+	return mua.Name
+}
+
+func (mua UnitAsset) GetServices() components.Services {
+	return mua.ServicesMap
+}
+
+func (mua UnitAsset) GetCervices() components.Cervices {
+	return mua.CervicesMap
+}
+
+func (mua UnitAsset) GetDetails() map[string][]string {
+	return mua.Details
+}
+
+func (mua UnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {}
+
 func createTestSystem(ctx context.Context, broken bool) components.System {
 	// instantiate the System
 	sys := components.NewSystem("testSystem", ctx)
@@ -99,6 +97,27 @@ func createTestSystem(ctx context.Context, broken bool) components.System {
 		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
 		InfoLink:    "https://for.testing.purposes",
 	}
+
+	testCerv := &components.Cervice{
+		Definition: "testCerv",
+		Details:    map[string][]string{"Forms": {"SignalA_v1a"}},
+		Nodes:      map[string][]string{},
+	}
+
+	CervicesMap := &components.Cervices{
+		testCerv.Definition: testCerv,
+	}
+
+	mua := &UnitAsset{
+		Name:        "testUnitAsset",
+		Details:     map[string][]string{"Test": {"Test"}},
+		CervicesMap: *CervicesMap,
+	}
+
+	sys.UAssets = make(map[string]*components.UnitAsset)
+	var muaInterface components.UnitAsset = mua
+	sys.UAssets[mua.GetName()] = &muaInterface
+
 	if broken == false {
 		orchestrator := &components.CoreSystem{
 			Name: "orchestrator",
@@ -123,9 +142,9 @@ func TestFillQuestForm(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	testSys := createTestSystem(ctx, false)
-	mua := mockUnitAsset{}
+	mua := UnitAsset{}
 	questForm := FillQuestForm(&testSys, mua, "TestDef", "TestProtocol")
-	// Loop through the details in questForm and mua (mockUnitAsset), error if they're same
+	// Loop through the details in questForm and mua (mockUnitAsset), error if they're not the same
 	for i, detail := range questForm.Details["Details"] {
 		if detail != mua.GetDetails()["Details"][i] {
 			t.Errorf("Expected %s, got: %s", mua.GetDetails()["Details"][i], detail)
@@ -166,6 +185,9 @@ func TestExtractQuestForm(t *testing.T) {
 	noVersionBody := testBodyNoVersion{}
 	data, _ = json.Marshal(noVersionBody)
 	rec, err = ExtractQuestForm(data)
+	if err != nil {
+		t.Errorf("Expected no errors")
+	}
 	if rec.Version != "" {
 		t.Errorf("Expected no version, got %s", rec.Version)
 	}
@@ -225,7 +247,7 @@ func TestSendHttpReq(t *testing.T) {
 		StatusCode: 200,
 		Body:       io.NopCloser(strings.NewReader(string("test body"))),
 	}
-	newMockTransport(resp, false, nil)
+	newMockTransport(resp, 0, nil)
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel()
 	var qForm forms.ServiceQuest_v1
@@ -250,7 +272,7 @@ func TestSendHttpReq(t *testing.T) {
 	cancel()
 
 	// Bad case: response returns error
-	newMockTransport(resp, true, errHTTP)
+	newMockTransport(resp, 1, errHTTP)
 	ctx, cancel = context.WithCancel(context.Background())
 	qForm.NewForm()
 	_, err = sendHttpReq(http.MethodPost, "https://test", jsonQF, ctx)
@@ -260,17 +282,6 @@ func TestSendHttpReq(t *testing.T) {
 	cancel()
 }
 
-/*
-	type ServiceQuest_v1 struct {
-		SysId             int                 `json:"systemId"`
-		RequesterName     string              `json:"requesterName"`
-		ServiceDefinition string              `json:"serrviceDefinition"`
-		Protocol          string              `json:"protocol"`
-		Details           map[string][]string `json:"details"`
-		Version           string              `json:"version"`
-		Break             any                 `json:"break"`
-	}
-*/
 func TestSearch4Service(t *testing.T) {
 	// Best case, everything pass
 	f := createServicePointTestForm()
@@ -284,7 +295,7 @@ func TestSearch4Service(t *testing.T) {
 		StatusCode: 200,
 		Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
 	}
-	newMockTransport(resp, false, nil)
+	newMockTransport(resp, 0, nil)
 	ctx, cancel := context.WithCancel(context.Background())
 	testSys := createTestSystem(ctx, false)
 	var qForm forms.ServiceQuest_v1
@@ -296,14 +307,13 @@ func TestSearch4Service(t *testing.T) {
 	if serviceForm.ServLocation != f.ServLocation {
 		t.Errorf("Expected %s, got: %s", f.ServLocation, serviceForm.ServLocation)
 	}
-
 	cancel()
 
 	// Error at "prepare the payload to perform a service quest"
 	// Untested because I found no way of breaking json.Marshal, without making big changes to the form
 
 	// Error while getting core system url
-	newMockTransport(resp, true, errHTTP)
+	newMockTransport(resp, 1, errHTTP)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
 	qForm.NewForm()
@@ -314,12 +324,20 @@ func TestSearch4Service(t *testing.T) {
 	cancel()
 
 	// Error at sendHttpRequest
-	// Can't be tested
+	newMockTransport(resp, 2, errHTTP)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	qForm.NewForm()
+	_, err = Search4Service(qForm, &testSys)
+	if err == nil {
+		t.Errorf("Expected error at GetRunningCoreSystemURL()")
+	}
+	cancel()
 
 	// Error at "Read the response", io.ReadAll()
 	f = createServicePointTestForm()
 	resp.Body = errReader(0)
-	newMockTransport(resp, false, nil)
+	newMockTransport(resp, 0, nil)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
 	qForm.NewForm()
@@ -332,7 +350,7 @@ func TestSearch4Service(t *testing.T) {
 	// Error at "Read the response", ExtractDiscoveryForm()
 	f = createServicePointTestForm()
 	resp.Body = io.NopCloser(strings.NewReader(string("test")))
-	newMockTransport(resp, false, nil)
+	newMockTransport(resp, 0, nil)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
 	qForm.NewForm()
@@ -344,30 +362,127 @@ func TestSearch4Service(t *testing.T) {
 
 }
 
-func TestSearch4Services(t *testing.T) {
-	return
-}
-
+// Search4Services(cer *components.Cervice, sys *components.System) (err error)
+// *forms.ServicePoint_v1
 /*
-   Id                int                 `json:"registryID"`
+   ServiceID         int                 `json:"serviceId"`
+   ProviderName      string              `json:"providerName"`
    ServiceDefinition string              `json:"definition"`
-   SystemName        string              `json:"systemName"`
-   ServiceNode       string              `json:"serviceNode"`
-   IPAddresses       []string            `json:"ipAddresses"`
-   ProtoPort         map[string]int      `json:"protoPort"`
    Details           map[string][]string `json:"details"`
-   Certificate       string              `json:"certificate"`
-   SubPath           string              `json:"subpath"`
-   RegLife           int                 `json:"registrationLife"`
+   ServLocation      string              `json:"serviceURL"`
+   ServNode          string              `json:"serviceNode"`
+   Token             string              `json:"token"`
    Version           string              `json:"version"`
-   Created           string              `json:"created"`
-   Updated           string              `json:"updated"`
-   EndOfValidity     string              `json:"endOfValidity"`
-   SubscribeAble     bool                `json:"subscribeAble"`
-   ACost             float64             `json:"activityCost"`
-   CUnit             string              `json:"costUnit"`
 */
 
+func createTestServicePoint() (f forms.ServicePoint_v1) {
+	f.ProviderName = "testProvider"
+	f.ServiceDefinition = "testDef"
+	f.Details = map[string][]string{
+		"Details": {"detail1", "detail2"},
+	}
+	f.Version = "ServicePoint_v1"
+	return
+}
+
+func TestSearch4Services(t *testing.T) {
+	// Best case: everything passes
+	fakeBody := createTestServicePoint()
+	data, err := json.Marshal(fakeBody)
+	if err != nil {
+		t.Error("Error in test during json.Marshal()")
+	}
+	resp := &http.Response{
+		Status:     "200 OK",
+		StatusCode: 200,
+		Body:       io.NopCloser(strings.NewReader(string(data))),
+	}
+	resp.Header = make(http.Header)
+	resp.Header.Set("Content-Type", "application/json")
+	newMockTransport(resp, 0, nil)
+	ctx, cancel := context.WithCancel(context.Background())
+	testSys := createTestSystem(ctx, false)
+	cer := (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+	err = Search4Services(cer, &testSys)
+	if err != nil {
+		t.Errorf("Expected no errors, got %v", err)
+	}
+	cancel()
+
+	// Bad case: GetRunningCoreSystemURL() returns error
+	newMockTransport(resp, 1, errHTTP)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, true) // true sets orchestrator url to a brokenURL
+	err = Search4Services(cer, &testSys)
+	if err == nil {
+		t.Errorf("Expected errors")
+	}
+	cancel()
+
+	// Bad case: Orchestrator url is ""
+	newMockTransport(resp, 0, nil)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	(*testSys.CoreS[0]).Url = ""
+	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+	err = Search4Services(cer, &testSys)
+	if err == nil {
+		t.Errorf("Expected errors")
+	}
+	cancel()
+
+	// Bad case: sendHttpReq() returns an error
+	// TODO: Fix this, maybe change the mockTransport to count number of times it's been called
+	// and then change the retError to true and it should fail.
+	newMockTransport(resp, 2, nil)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+	err = Search4Services(cer, &testSys)
+	if err == nil {
+		t.Errorf("Expected errors")
+	}
+	cancel()
+
+	// Bad case: Response status code is < 200 or >= 300
+	resp.StatusCode = 199
+	newMockTransport(resp, 4, errHTTP)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+	err = Search4Services(cer, &testSys)
+	if err == nil {
+		t.Errorf("Expected errors")
+	}
+	cancel()
+
+	// Bad case: io.ReadAll() return an error
+	resp.StatusCode = 200
+	resp.Body = errReader(0)
+	newMockTransport(resp, 0, nil)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+	err = Search4Services(cer, &testSys)
+	if err == nil {
+		t.Errorf("Expected errors")
+	}
+	cancel()
+
+	// Bad case: Unpack() returns an error
+	resp.Body = io.NopCloser(strings.NewReader(string(data)))
+	resp.Header.Set("Content-Type", "Error")
+	newMockTransport(resp, 0, nil)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+	err = Search4Services(cer, &testSys)
+	if err == nil {
+		t.Errorf("Expected errors")
+	}
+	cancel()
+}
+
 func createTestServiceRecord(number int) (f forms.ServiceRecord_v1) {
 	f.Id = number
 	f.ServiceDefinition = fmt.Sprintf("testDefinition%d", number)
@@ -428,7 +543,8 @@ func TestExtractDiscoveryForm(t *testing.T) {
 	if form.ServLocation != "TestService" {
 		t.Errorf("Expected service location: %s, got %s", "TestService", form.ServLocation)
 	}
-	// Bad case: wrong form version
+
+	// Bad case: Default switch case, wrong form version
 	spForm.Version = ""
 	data, err = json.Marshal(spForm)
 	if err != nil {
@@ -439,24 +555,28 @@ func TestExtractDiscoveryForm(t *testing.T) {
 		t.Errorf("Expected error because of wrong form version")
 	}
 
-	// Bad case: error when unmarshalling body
-	data, err = json.Marshal("Test")
+	// Bad case: version key not found
+	data, err = json.Marshal(nil)
 	if err != nil {
 		t.Errorf("Error when marshalling in test")
 	}
 	form, err = ExtractDiscoveryForm(data)
 	if err == nil {
-		t.Errorf("Expected errors for broken unmarshal")
+		t.Errorf("Expected errors for missing form")
 	}
 
-	// Bad case: error when unmarshalling body
-	var emptyForm forms.Form
-	data, err = json.Marshal(emptyForm)
+	// Bad case: Unmarshalling body bytes to forms.ServicePoint_v1
+	// Needed to create my own map, with the correct version but a field that had a different type
+	// than the target field in order to break unmarshal
+	wrongForm := make(map[string]any)
+	wrongForm["version"] = "ServicePoint_v1"
+	wrongForm["serviceId"] = false // Target field is an int
+	data, err = json.Marshal(wrongForm)
 	if err != nil {
 		t.Errorf("Error when marshalling in test")
 	}
 	form, err = ExtractDiscoveryForm(data)
 	if err == nil {
-		t.Errorf("Expected errors for missing form")
+		t.Errorf("Expected errors for wrong form")
 	}
 }

From 53148f87dd391b379332622cd451732739944630 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 12 Jun 2025 14:58:06 +0200
Subject: [PATCH 031/186] Simplified test for ExtractQuestForm()

---
 usecases/serviceDiscovery_test.go | 115 +++++++++++++++++++-----------
 1 file changed, 72 insertions(+), 43 deletions(-)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index ceebc46..feac37a 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -3,6 +3,7 @@ package usecases
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -163,53 +164,81 @@ type testBodyHasVersion struct {
 
 type testBodyNoVersion struct{}
 
-func TestExtractQuestForm(t *testing.T) {
-	body := testBodyHasVersion{
-		Version: "ServiceQuest_v1",
+func createTestData(bodyType string, proto int, version string, errRead bool) (data []byte, err error) {
+	if errRead == true {
+		return json.Marshal(errReader(0))
 	}
-	data, _ := json.Marshal(body)
-
-	// Everything passes, best outcome
-	rec, _ := ExtractQuestForm(data)
-	if rec.Version != body.Version {
-		t.Errorf("Expected version: %s, got: %s", rec.Version, body.Version)
+	switch bodyType {
+	case "testBodyHasProtocol":
+		body := testBodyHasProtocol{
+			Protocol: proto,
+			Version:  version,
+		}
+		data, err := json.Marshal(body)
+		if err != nil {
+			return nil, err
+		}
+		return data, nil
+	case "testBodyHasVersion":
+		body := testBodyHasVersion{
+			Version: version,
+		}
+		data, err := json.Marshal(body)
+		if err != nil {
+			return nil, err
+		}
+		return data, nil
+	case "testBodyNoVersion":
+		body := testBodyNoVersion{}
+		data, err := json.Marshal(body)
+		if err != nil {
+			return nil, err
+		}
+		return data, nil
+	default:
+		return nil, errors.New("Body type not supported")
 	}
+}
 
-	// Can't unmarshal data
-	data, _ = json.Marshal(errReader(0))
-	rec, err := ExtractQuestForm(data)
-	if err == nil {
-		t.Errorf("Expected error during unmarshal")
-	}
-	// Missing version
-	noVersionBody := testBodyNoVersion{}
-	data, _ = json.Marshal(noVersionBody)
-	rec, err = ExtractQuestForm(data)
-	if err != nil {
-		t.Errorf("Expected no errors")
-	}
-	if rec.Version != "" {
-		t.Errorf("Expected no version, got %s", rec.Version)
-	}
-	// Error while writing to correct form
-	protocolBody := testBodyHasProtocol{
-		Version:  "ServiceQuest_v1",
-		Protocol: 123,
-	}
-	data, _ = json.Marshal(protocolBody)
-	rec, err = ExtractQuestForm(data)
-	if err == nil {
-		t.Errorf("Expected Error during unmarshal in switch case")
-	}
+type params struct {
+	testCase      string
+	bodyType      string
+	protocol      int
+	version       string
+	errRead       bool
+	expectedError bool
+}
 
-	// Switch case: Unsupported service registration form
-	body = testBodyHasVersion{
-		Version: "",
-	}
-	data, _ = json.Marshal(body)
-	rec, err = ExtractQuestForm(data)
-	if err == nil {
-		t.Errorf("Expected error in switch case (Unsupported form version)")
+func TestExtractQuestForm(t *testing.T) {
+	// A list holding structs containing the parameters used for the test
+	testParams := []params{
+		// {"testCase", "bodyType", "protocol", "version", "errRead", "expectedError"}
+		{"No errors", "testBodyHasVersion", -1, "ServiceQuest_v1", false, false},
+		{"Error during Unmarshal", "testBodyHasVersion", -1, "ServiceQuest_v1", true, true},
+		{"Missing version", "testBodyNoVersion", -1, "", false, false},
+		{"Error while writing to correct form", "testBodyHasProtocol", 123, "ServiceQuest_v1", false, true},
+		{"Error Unsupported version", "testBodyHasVersion", -1, "", false, true},
+	}
+	for _, x := range testParams {
+		// Create the data []byte that will be sent into the function
+		data, err := createTestData(x.bodyType, x.protocol, x.version, x.errRead)
+		if err != nil {
+			t.Errorf("---\tError occured while creating test data")
+		}
+		// Do the test
+		rec, err := ExtractQuestForm(data)
+		if x.testCase == "No errors" || x.testCase == "Missing version" {
+			if err != nil {
+				t.Errorf("Test case: '%s' got error: %e", x.testCase, err)
+			}
+			if x.testCase == "Missing version" && rec.Version != "" {
+				t.Errorf("---\tExpected no version, got %s", rec.Version)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("---\tTest case: Expected errors in '%s', got none", x.testCase)
+			}
+		}
 	}
 }
 

From b4b66190ecc167a7cb46633ee36b181c2c34e536 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 12 Jun 2025 15:01:06 +0200
Subject: [PATCH 032/186] Fixed typo

---
 usecases/serviceDiscovery_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index feac37a..678f954 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -223,7 +223,7 @@ func TestExtractQuestForm(t *testing.T) {
 		// Create the data []byte that will be sent into the function
 		data, err := createTestData(x.bodyType, x.protocol, x.version, x.errRead)
 		if err != nil {
-			t.Errorf("---\tError occured while creating test data")
+			t.Errorf("---\tError occurred while creating test data")
 		}
 		// Do the test
 		rec, err := ExtractQuestForm(data)
@@ -242,6 +242,7 @@ func TestExtractQuestForm(t *testing.T) {
 	}
 }
 
+// Creates a ServicePoint_v1 form with test values
 func createServicePointTestForm() forms.ServicePoint_v1 {
 	var f forms.ServicePoint_v1
 	f.NewForm()

From 092ae66eedbd3e7d6f43f6a9fe772b0ea5860d3e Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Thu, 12 Jun 2025 15:28:34 +0200
Subject: [PATCH 033/186] Added all tests and made comments in the test file
 for the different tests

---
 usecases/registration.go      |  10 +-
 usecases/registration_test.go | 820 +++++++++++++++++++++++++---------
 2 files changed, 627 insertions(+), 203 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index 81b88b7..bf45522 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -140,8 +140,11 @@ func RegisterServices(sys *components.System) {
 
 */
 
-func DiscoverLeadingRegistrar(sys *components.System, manualTicker time.Duration) *components.CoreSystem {
+func DiscoverLeadingRegistrar(sys *components.System, manualTicker time.Duration, leadingRegistrarTest bool) *components.CoreSystem {
 	var leadingRegistrar *components.CoreSystem
+	if leadingRegistrarTest == true {
+		leadingRegistrar = sys.CoreS[1]
+	}
 	// Create a buffered channel for the pointer to the leading service registrar
 	registrarStream := make(chan *components.CoreSystem, 1)
 	defer close(registrarStream)
@@ -209,7 +212,7 @@ func DiscoverLeadingRegistrar(sys *components.System, manualTicker time.Duration
 	}
 }
 
-func HandleLeadingRegistrar(sys *components.System, manualTicker time.Duration, leadingRegistrarTest bool) {
+func HandleLeadingRegistrar(sys *components.System, manualTicker time.Duration, leadingRegistrarTest bool) (delay time.Duration, err error) {
 
 	var leadingRegistrar *components.CoreSystem
 	if leadingRegistrarTest == true {
@@ -240,11 +243,12 @@ func HandleLeadingRegistrar(sys *components.System, manualTicker time.Duration,
 					if err != nil {
 						fmt.Println("Something went wrong with deregistration of service:", err)
 					}
-					return
+					return delay, err
 				}
 			}
 		}
 	}
+	return delay, err
 }
 
 // registerService makes a POST or PUT request to register or register individual services
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index b172144..9e7a76a 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -1,67 +1,60 @@
 package usecases
 
 import (
-	//"bytes"
 	"context"
 	"encoding/json"
-	"io"
-	"strings"
-
-	//"sync"
-	"time"
-
-	//"encoding/json"
-	//"errors"
+	"errors"
 	"fmt"
-	//"io"
-	//"log"
-	//"net"
+	"io"
 	"net/http"
-	"net/http/httptest"
-
-	//"strconv"
-	//"strings"
-	"testing"
-	//"time"
 	"reflect"
+	"strings"
+	"testing"
+	"time"
 
 	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
-	//"github.com/sdoque/mbaigo/forms"
 )
 
 type mockTransport struct {
 	returnError bool
-	resp        *http.Response
-	hits        map[string]int
+	respFunc    func() *http.Response
+	hits        int
 	err         error
 }
 
-func newMockTransport(resp *http.Response, retErr bool, err error) mockTransport {
+func newMockTransport(respFunc func() *http.Response, v int, err error) mockTransport {
 	t := mockTransport{
-		returnError: retErr,
-		resp:        resp,
-		err:         err,
+		hits:     v,
+		respFunc: respFunc,
+		err:      err,
 	}
 	http.DefaultClient.Transport = t
 	return t
 }
 
-func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-	if t.err != nil {
+func (t mockTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	t.hits -= 1
+	if t.hits == 0 {
 		return nil, t.err
 	}
-	if t.returnError != false {
-		req.GetBody = func() (io.ReadCloser, error) {
-			return nil, errHTTP
-		}
-	}
-	t.resp.Request = req
-	return t.resp, nil
+	resp := t.respFunc()
+	resp.Request = req
+	return resp, nil
 }
 
 type timeoutError struct{}
 
+type errorReadCloser struct{}
+
+func (e *errorReadCloser) Read(p []byte) (int, error) {
+	return 0, io.EOF
+}
+
+func (e *errorReadCloser) Close() error {
+	return errors.New("Forced close error")
+}
+
 func (timeoutError) Error() string   { return "timeout" }
 func (timeoutError) Timeout() bool   { return true }
 func (timeoutError) Temporary() bool { return true }
@@ -181,197 +174,487 @@ func createTestSystem(ctx context.Context) components.System {
 }
 
 func TestDiscoverLeadingRegistrar(t *testing.T) {
-	statusCode := http.StatusOK
-	responseBody := "lead Service Registrar since"
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(statusCode)
-		w.Write([]byte(responseBody))
-	}))
-	defer ts.Close()
-	testURL := ts.URL
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx)
-
-	testSys.CoreS[1].Url = testURL
+	// Create a new Test System to run the test on
+	ctx1, cancel1 := context.WithCancel(context.Background())
+	defer cancel1()
+	testSys1 := createTestSystem(ctx1)
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Good case: Everything works in the case that there is no immediate leading registrar
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	respFunc1 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
+		}
+	}
+	newMockTransport(respFunc1, 0, nil)
 
 	manualTicker := 10 * time.Millisecond
 
-	resultCh := make(chan *components.CoreSystem, 1)
-	defer close(resultCh)
+	resultCh1 := make(chan *components.CoreSystem, 1)
+	defer close(resultCh1)
 	go func() {
-		resultCh <- DiscoverLeadingRegistrar(&testSys, manualTicker)
+		res1 := DiscoverLeadingRegistrar(&testSys1, manualTicker, false)
+		resultCh1 <- res1
 	}()
 	time.Sleep(5 * manualTicker)
-	cancel()
-	select {
-	case res := <-resultCh:
-		if res.Name != "serviceregistrar" {
-			t.Errorf("Expected %s, got: %s", "serviceregistrar", res.Name)
+	cancel1()
+	leadReg1 := <-resultCh1
+	if leadReg1.Name != "serviceregistrar" {
+		t.Errorf("Expected %s, got: %s", "serviceregistrar", leadReg1.Name)
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: Broken URL
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	ctx2, cancel2 := context.WithCancel(context.Background())
+	defer cancel2()
+	testSys2 := createTestSystem(ctx2)
+
+	respFunc2 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
 		}
-	case <-time.After(200 * time.Millisecond):
-		t.Error("Timeout waiting for DiscoverLeadingRegistrar result")
 	}
 
-	statusCode = http.StatusOK
-	responseBody = "wrong response"
-	testURL = ts.URL
-	testSys.CoreS[1].Url = testURL
+	newMockTransport(respFunc2, 0, nil)
+	testSys2.CoreS[1].Url = brokenUrl
+	resultCh2 := make(chan *components.CoreSystem, 1)
+	defer close(resultCh2)
 	go func() {
-		resultCh <- DiscoverLeadingRegistrar(&testSys, manualTicker)
+		res2 := DiscoverLeadingRegistrar(&testSys2, manualTicker, false)
+		resultCh2 <- res2
 	}()
 	time.Sleep(5 * manualTicker)
-	cancel()
-	select {
-	case res := <-resultCh:
-		if res != nil {
-			t.Errorf("Expected %s, got: %s", "leadingRegistrar be nil", res.Name)
+	cancel2()
+	leadReg2 := <-resultCh2
+	if leadReg2 != nil {
+		t.Errorf("Expected the leading registrar to be nil, got: %v", leadReg2)
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: io.ReadAll() returns an error
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	ctx3, cancel3 := context.WithCancel(context.Background())
+	defer cancel3()
+	testSys3 := createTestSystem(ctx3)
+
+	respFunc3 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(errorReader{}),
 		}
-	case <-time.After(200 * time.Millisecond):
-		t.Error("Timeout waiting for DiscoverLeadingRegistrar result")
 	}
 
-	statusCode = http.StatusOK
-	responseBody = "lead Service Registrar since"
-	testURL = ts.URL
-	testSys.CoreS[1].Url = testURL
-	ts.Close()
+	newMockTransport(respFunc3, 0, nil)
+	resultCh3 := make(chan *components.CoreSystem, 1)
+	defer close(resultCh3)
 	go func() {
-		resultCh <- DiscoverLeadingRegistrar(&testSys, manualTicker)
+		res3 := DiscoverLeadingRegistrar(&testSys3, manualTicker, false)
+		resultCh3 <- res3
 	}()
 	time.Sleep(5 * manualTicker)
-	cancel()
-	select {
-	case res := <-resultCh:
-		if res != nil {
-			t.Errorf("Expected %s, got: %s", "leadingRegistrar be nil since Get() error", res.Name)
-		}
-	case <-time.After(200 * time.Millisecond):
-		t.Error("Timeout waiting for DiscoverLeadingRegistrar result")
+	cancel3()
+	leadReg3 := <-resultCh3
+	if leadReg3 != nil {
+		t.Errorf("Expected an error when reading the response body, got: %v", leadReg3)
 	}
 
-	/*
-		result := DiscoverLeadingRegistrar(&testSys, testURL, false)
-		if result != true {
-			t.Errorf("Expected %t, got: %t", true, result)
-		}
-	*/
-
-	/*
-		statusCode = http.StatusBadRequest
-		responseBody = "lead Service Registrar since"
-		result = DiscoverLeadingRegistrar(&testSys, ts.URL, false)
-		if result != false {
-			t.Errorf("Expected %t, got: %t", false, result)
-		}
-	*/
-
-	/*
-		statusCode = http.StatusOK
-		responseBody = "wrong response"
-		testURL = ts.URL
-		result = DiscoverLeadingRegistrar(&testSys, testURL, false)
-		if result != false {
-			t.Errorf("Expected %t, got: %t", false, result)
-		}
-	*/
-
-	/*
-		statusCode = http.StatusBadRequest
-		responseBody = "wrong response"
-		result = DiscoverLeadingRegistrar(&testSys, ts.URL, false)
-		if result != false {
-			t.Errorf("Expected %t, got: %t", false, result)
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: Closing the response body returns an error (no real way to see this as the error handling for that does nothing)
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	ctx4, cancel4 := context.WithCancel(context.Background())
+	defer cancel4()
+	testSys4 := createTestSystem(ctx4)
+
+	respFunc4 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       &errorReadCloser{},
 		}
-	*/
-
-	/*
-		statusCode = http.StatusOK
-		responseBody = "lead Service Registrar since"
-		testURL = ts.URL
-		result = DiscoverLeadingRegistrar(&testSys, testURL, true)
-		if result != true {
-			t.Errorf("Expected %t, got: %t", true, result)
+	}
+
+	newMockTransport(respFunc4, 0, nil)
+	resultCh4 := make(chan *components.CoreSystem, 1)
+	defer close(resultCh4)
+	go func() {
+		res4 := DiscoverLeadingRegistrar(&testSys4, manualTicker, false)
+		resultCh4 <- res4
+	}()
+	time.Sleep(5 * manualTicker)
+	cancel4()
+	leadReg4 := <-resultCh4
+	if leadReg4 != nil {
+		t.Errorf("Expected an error when closing the response body, got: %v", leadReg4)
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Good case: But the leading registrar is not null in the beginning
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	ctx5, cancel5 := context.WithCancel(context.Background())
+	defer cancel5()
+	testSys5 := createTestSystem(ctx5)
+
+	respFunc5 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
 		}
+	}
+
+	newMockTransport(respFunc5, 0, nil)
+	resultCh5 := make(chan *components.CoreSystem, 1)
+	defer close(resultCh5)
+	go func() {
+		res5 := DiscoverLeadingRegistrar(&testSys5, manualTicker, true)
+		resultCh5 <- res5
+	}()
+	time.Sleep(5 * manualTicker)
+	cancel5()
+	leadReg5 := <-resultCh5
+	if leadReg5.Name != "serviceregistrar" {
+		t.Errorf("Expected the lead registrars name to be: %s, got: %s", "serviceregistrar", leadReg5.Name)
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: Broken URL, with leading registrar from the beginning
+	// -- -- -- -- -- -- -- -- -- -- //
 
-		statusCode = http.StatusOK
-		responseBody = "wrong response"
-		testURL = ts.URL
-		result = DiscoverLeadingRegistrar(&testSys, testURL, true)
-		if result != false {
-			t.Errorf("Expected %t, got: %t", false, result)
+	ctx6, cancel6 := context.WithCancel(context.Background())
+	defer cancel6()
+	testSys6 := createTestSystem(ctx6)
+
+	respFunc6 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
 		}
-	*/
-
-	/*
-		statusCode = http.StatusBadRequest
-		responseBody = "lead Service Registrar since"
-		result = DiscoverLeadingRegistrar(&testSys, ts.URL, true)
-		if result != false {
-			t.Errorf("Expected %t, got: %t", false, result)
+	}
+
+	newMockTransport(respFunc6, 0, nil)
+	testSys6.CoreS[1].Url = brokenUrl
+	resultCh6 := make(chan *components.CoreSystem, 1)
+	defer close(resultCh6)
+	go func() {
+		res6 := DiscoverLeadingRegistrar(&testSys6, manualTicker, true)
+		resultCh6 <- res6
+	}()
+	time.Sleep(5 * manualTicker)
+	cancel6()
+	leadReg6 := <-resultCh6
+	if leadReg6 != nil {
+		t.Errorf("Expected leading registrar to be nil since broken URL in Get() method, got: %v", leadReg6)
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: io.ReadAll() returns an error, with leading registrar from the beginning
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	ctx7, cancel7 := context.WithCancel(context.Background())
+	defer cancel7()
+	testSys7 := createTestSystem(ctx7)
+
+	respFunc7 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(errorReader{}),
 		}
+	}
 
-		statusCode = http.StatusBadRequest
-		responseBody = "wrong response"
-		result = DiscoverLeadingRegistrar(&testSys, ts.URL, true)
-		if result != false {
-			t.Errorf("Expected %t, got: %t", false, result)
+	newMockTransport(respFunc7, 0, nil)
+	resultCh7 := make(chan *components.CoreSystem, 1)
+	defer close(resultCh7)
+	go func() {
+		res7 := DiscoverLeadingRegistrar(&testSys7, manualTicker, true)
+		resultCh7 <- res7
+	}()
+	time.Sleep(5 * manualTicker)
+	cancel7()
+	leadReg7 := <-resultCh7
+	if leadReg7 != nil {
+		t.Errorf("Expected an error when reading the response body, got: %v", leadReg7)
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: The previous leading registrar has been lost. i.e. Prefix in bodyBytes string is not "lead Service Registrar since", with leading registrar from the beginning
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	ctx8, cancel8 := context.WithCancel(context.Background())
+	defer cancel8()
+	testSys8 := createTestSystem(ctx8)
+
+	respFunc8 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(""))),
 		}
-	*/
+	}
+
+	newMockTransport(respFunc8, 0, nil)
+	resultCh8 := make(chan *components.CoreSystem, 1)
+	defer close(resultCh8)
+	go func() {
+		res8 := DiscoverLeadingRegistrar(&testSys8, manualTicker, true)
+		resultCh8 <- res8
+	}()
+	time.Sleep(5 * manualTicker)
+	cancel8()
+	leadReg8 := <-resultCh8
+	if leadReg8 != nil {
+		t.Errorf("Expected the lead registrar to be nil since it is lost, got: %s", leadReg8)
+	}
 }
 
-/*
 func TestHandleLeadingRegistrar(t *testing.T) {
-	statusCode := http.StatusOK
-	responseBody := "lead Service Registrar since"
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(statusCode)
-		w.Write([]byte(responseBody))
-	}))
-	defer ts.Close()
-	testURL := ts.URL
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx)
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Good case, everything works, the system has UnitAssets
+	// -- -- -- -- -- -- -- -- -- -- //
 
-	testSys.CoreS[1].Url = testURL
+	ctx1, cancel1 := context.WithCancel(context.Background())
+	defer cancel1()
+	testSys1 := createTestSystem(ctx1)
+	mua1 := testSys1.UAssets["mockUnitAsset"]
+	serv1 := (*testSys1.UAssets["mockUnitAsset"]).GetServices()["test"]
 
-	manualTicker := 10 * time.Millisecond
+	payload1, err1 := ServiceRegistrationForm(&testSys1, mua1, serv1, "ServiceRecord_v1")
+
+	if err1 != nil {
+		t.Fatalf("The Service Record version was wrong.")
+	}
+
+	var sr1 forms.ServiceRecord_v1
+	if err := json.Unmarshal(payload1, &sr1); err != nil {
+		t.Fatalf("Invalid JSON: %v", err)
+	}
+
+	sr1.EndOfValidity = time.Now().Format(time.RFC3339)
+
+	fakeBody1, err := json.Marshal(sr1)
+	if err != nil {
+		t.Errorf("Fail Marshal at start of test")
+	}
+
+	respFunc1 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody1))),
+		}
+	}
+	newMockTransport(respFunc1, 0, nil)
+
+	manualTicker := 50 * time.Millisecond
+	resultTest1 := make(chan time.Duration, 1)
+	resultErr1 := make(chan error, 1)
+
+	go func() {
+		dur1, err1 := HandleLeadingRegistrar(&testSys1, manualTicker, false)
+		resultTest1 <- dur1
+		resultErr1 <- err1
+	}()
+	time.Sleep(100 * time.Millisecond)
+	cancel1()
+	res1 := <-resultTest1
+	resErr1 := <-resultErr1
+	if int(res1.Seconds()) != 15 {
+		t.Errorf("Expected the delay to be 15 seconds since there is no leading registrar, got: %d", int(res1.Seconds()))
+	}
+	if resErr1 != nil {
+		t.Errorf("Expected the error to be nil since there is no need to deregister a service that is not registered, got: %v", err)
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Good case, when leading registrar is not null in the beginning
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	ctx2, cancel2 := context.WithCancel(context.Background())
+	defer cancel2()
+	testSys2 := createTestSystem(ctx2)
+	mua2 := testSys2.UAssets["mockUnitAsset"]
+	serv2 := (*testSys2.UAssets["mockUnitAsset"]).GetServices()["test"]
+
+	payload2, err2 := ServiceRegistrationForm(&testSys2, mua2, serv2, "ServiceRecord_v1")
+
+	if err2 != nil {
+		t.Fatalf("The Service Record version was wrong.")
+	}
+
+	var sr2 forms.ServiceRecord_v1
+	if err = json.Unmarshal(payload2, &sr2); err != nil {
+		t.Fatalf("Invalid JSON: %v", err)
+	}
+
+	sr2.EndOfValidity = time.Now().Format(time.RFC3339)
+
+	fakeBody2, err := json.Marshal(sr2)
+	if err != nil {
+		t.Errorf("Fail Marshal at start of test")
+	}
+
+	respFunc2 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody2))),
+		}
+	}
+
+	newMockTransport(respFunc2, 0, nil)
+	resultTest2 := make(chan time.Duration, 1)
+	resultErr2 := make(chan error, 1)
+	go func() {
+		dur2, err2 := HandleLeadingRegistrar(&testSys2, manualTicker, true)
+		resultTest2 <- dur2
+		resultErr2 <- err2
+	}()
+	time.Sleep(100 * time.Millisecond)
+	cancel2()
+	res2 := <-resultTest2
+	resErr2 := <-resultErr2
+	if int(res2.Seconds()) > 0 {
+		t.Errorf("Expected the delay to be negative since the service should have been registered, got: %d", int(res2.Seconds()))
+	}
+	if resErr2 != nil {
+		t.Errorf("Expected the service to be able to deregistered, got: %v", err)
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case, error when deregistring the service
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	ctx3, cancel3 := context.WithCancel(context.Background())
+	defer cancel3()
+	testSys3 := createTestSystem(ctx3)
+	mua3 := testSys3.UAssets["mockUnitAsset"]
+	serv3 := (*testSys3.UAssets["mockUnitAsset"]).GetServices()["test"]
+
+	payload3, err3 := ServiceRegistrationForm(&testSys3, mua3, serv3, "ServiceRecord_v1")
+
+	if err3 != nil {
+		t.Fatalf("The Service Record version was wrong.")
+	}
+
+	var sr3 forms.ServiceRecord_v1
+	if err = json.Unmarshal(payload3, &sr3); err != nil {
+		t.Fatalf("Invalid JSON: %v", err)
+	}
+
+	sr3.EndOfValidity = time.Now().Format(time.RFC3339)
+
+	fakeBody3, err := json.Marshal(sr3)
+	if err != nil {
+		t.Errorf("Fail Marshal at start of test")
+	}
+
+	respFunc3 := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody3))),
+		}
+	}
 
+	newMockTransport(respFunc3, 1, errHTTP)
+	resultTest3 := make(chan time.Duration, 1)
+	resultErr3 := make(chan error, 1)
 	go func() {
-		HandleLeadingRegistrar(&testSys, manualTicker, false)
+		dur3, err3 := HandleLeadingRegistrar(&testSys3, manualTicker, true)
+		resultTest3 <- dur3
+		resultErr3 <- err3
 	}()
 	time.Sleep(100 * time.Millisecond)
-	cancel()
+	cancel3()
+	resErr3 := <-resultErr3
+	if resErr3 == nil {
+		t.Errorf("Expected an error when deregistring the service, got: %v", resErr3)
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Neutral case, the system has no UAssets so it won't either register or deregister anything
+	// -- -- -- -- -- -- -- -- -- -- //
 
+	ctx4, cancel4 := context.WithCancel(context.Background())
+	defer cancel4()
+	testSys4 := createTestSystem(ctx4)
+	testSys4.UAssets = nil
+
+	resultTest4 := make(chan time.Duration, 1)
+	resultErr4 := make(chan error, 1)
 	go func() {
-		HandleLeadingRegistrar(&testSys, manualTicker, true)
+		dur4, err4 := HandleLeadingRegistrar(&testSys4, manualTicker, true)
+		resultTest4 <- dur4
+		resultErr4 <- err4
 	}()
 	time.Sleep(100 * time.Millisecond)
-	cancel()
+	cancel4()
+	res4 := <-resultTest4
+	if res4 != 0 {
+		t.Errorf("Expected the delay to be 0 (time.Duration zero value) since the system has no UAssets, got: %d", int(res4.Seconds()))
+	}
 }
-*/
 
 func TestDeepCopyMap(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	testSys := createTestSystem(ctx)
-	// Use the correct key to access the map; here we use "mockUnitAsset" as set in createTestSystem
 	mua := testSys.UAssets["mockUnitAsset"]
 	original := (*mua).GetDetails()
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Create a Deep Copy Map of the mockUnitAsset's Details
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	test := DeepCopyMap((*mua).GetDetails())
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// If they are not equal from the beginning then the copy was not successful
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	if !reflect.DeepEqual(original, test) {
 		t.Errorf("Expected deep copied map to be equal to original, Expected: %v, got: %v", original, test)
 	}
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// When we change something in the original, the deep copied map should not change
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	original["Test"][0] = "changed original"
 	if reflect.DeepEqual(original, test) {
 		t.Errorf("Deep copy failed, changes in original affected the deep copied map. Expected: %v, got %v", original, test)
 	}
 	original["Test"][0] = "test"
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// When we change something in the deep copied map, the original should not change
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	test["Test"][0] = "changed deep copy"
 	if reflect.DeepEqual(original, test) {
 		t.Errorf("Deep copy failed, changes in deep copied map affected the original. Expected: %v, got %v", original, test)
@@ -386,8 +669,16 @@ func TestServiceRegistrationForm(t *testing.T) {
 	serv := (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"]
 	version := "ServiceRecord_v1"
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Call the ServiceRegistrationForm with the correct parameters
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	payload, err := ServiceRegistrationForm(&testSys, mua, serv, version)
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Check that there was no error in the function (can only be when wrong Service Record version is sent in)
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	if err != nil {
 		t.Fatalf("The Service Record version was wrong.")
 	}
@@ -397,24 +688,43 @@ func TestServiceRegistrationForm(t *testing.T) {
 		t.Fatalf("Invalid JSON: %v", err)
 	}
 
-	// Set the first part to your Hosts name
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Check that the ServiceNode is created correctly
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	expectedNode := testSys.Host.Name + "_" + testSys.Name + "_" + (*testSys.UAssets["mockUnitAsset"]).GetName() + "_" + (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"].Definition
 	if sr.ServiceNode != expectedNode {
 		t.Errorf("Expected ServiceNode %q, got: %q", expectedNode, sr.ServiceNode)
 	}
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Check that the ProtoPorts that are equal to 0 gets removed
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	if len(sr.ProtoPort) != 1 {
 		t.Errorf("Expected: one proto port (excluding 0s), got: %v", sr.ProtoPort)
 	}
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Check that the unit asset details exists and are ok
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	if v, ok := sr.Details["Test"]; !ok || len(v) != 1 {
 		t.Errorf("Missing or incorrect unit asset details. Expected: %v, got: %v", (*mua).GetDetails(), v)
 	}
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Check that the service forms exists and are ok
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	if v, ok := sr.Details["Forms"]; !ok || len(v) != 1 {
-		t.Errorf("Missing or incorrect unit asset details. Expected: %v, got: %v", (*serv).Details, v)
+		t.Errorf("Missing or incorrect service forms. Expected: %v, got: %v", (*serv).Details, v)
 	}
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: Sent in version is not supported
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	version = "UnknownVersion"
 	_, err = ServiceRegistrationForm(&testSys, mua, serv, version)
 	if err == nil {
@@ -424,6 +734,10 @@ func TestServiceRegistrationForm(t *testing.T) {
 		t.Errorf("Expected error: unsupported service registration form version, got: %v", err)
 	}
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Check that when the Service RegPeriod equals 0, ServiceRegistrationForm defaults to its RegLife default value of 30
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	(*testSys.UAssets["mockUnitAsset"]).GetServices()["test"].RegPeriod = 0
 	version = "ServiceRecord_v1"
 	payload, err = ServiceRegistrationForm(&testSys, mua, serv, version)
@@ -447,18 +761,29 @@ func TestDeregisterService(t *testing.T) {
 	var registrar *components.CoreSystem
 	serv := (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"]
 
-	resp := &http.Response{
-		Status:     "200 OK",
-		StatusCode: 200,
-		Body:       io.NopCloser(strings.NewReader(string("test body"))),
+	respFunc := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Body:       io.NopCloser(strings.NewReader(string("test body"))),
+		}
 	}
-	newMockTransport(resp, false, nil)
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Good case: No errors when a service not registered tries to get deregistered
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 0, nil)
 
 	err := DeregisterService(registrar, serv)
 	if err != nil {
 		t.Errorf("Expected error: %v, got: %v", nil, err)
 	}
 
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Good case: No errors when a service registered tries to get deregistered
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	registrar = testSys.CoreS[1]
 
 	err = DeregisterService(registrar, serv)
@@ -466,15 +791,21 @@ func TestDeregisterService(t *testing.T) {
 		t.Errorf("Expected error: %v, got: %v", nil, err)
 	}
 
+	// -- -- -- -- -- -- -- -- -- -- //
 	// bad case: response body error
-	newMockTransport(resp, true, errHTTP)
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 1, errHTTP)
 	err = DeregisterService(registrar, serv)
 	if err == nil {
 		t.Errorf("Expected error while sending http request")
 	}
 
+	// -- -- -- -- -- -- -- -- -- -- //
 	// bad case: URL broken
-	newMockTransport(resp, false, nil)
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 0, nil)
 	registrar.Url = brokenUrl
 	err = DeregisterService(registrar, serv)
 	if err == nil {
@@ -486,6 +817,11 @@ func TestServiceRegistrationFormList(t *testing.T) {
 	list := []string{
 		"ServiceRecord_v1",
 	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Check that the return value of ServiceRegistrationFormsList is equal to the expected list of ServiceRegistrationForms
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	test := ServiceRegistrationFormsList()
 	if !reflect.DeepEqual(list, test) {
 		t.Errorf("Expected lists to be equal. Expected: %v, got: %v", list, test)
@@ -512,37 +848,42 @@ func TestRegisterService(t *testing.T) {
 	}
 
 	sr.EndOfValidity = time.Now().Format(time.RFC3339)
-
 	fakeBody, err := json.Marshal(sr)
 	if err != nil {
 		t.Errorf("Fail Marshal at start of test")
 	}
 
-	// Good case
-	resp := &http.Response{
-		Status:     "200 OK",
-		StatusCode: 200,
-		Header:     http.Header{"Content-Type": []string{"application/json"}},
-		Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+	respFunc := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+		}
 	}
-	newMockTransport(resp, false, nil)
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Good case, everything works, service gets registered
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 0, nil)
 
 	test := RegisterService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) > 0 {
 		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
 	}
-	fmt.Println("Delay is: ", int(test.Seconds()))
 
-	// Bad case: when NewRequest with PUT method fails:
-	newMockTransport(resp, false, nil)
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: when NewRequest with PUT method fails
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 0, nil)
 	registrar.Url = brokenUrl
 	test = RegisterService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since NewRequest with PUT method should have failed, got: %d", int(test.Seconds()))
 	}
-	fmt.Println("Delay is: ", int(test.Seconds()))
 
-	// Good case when making POST instead
 	registrar.Url = "https://leadingregistrar"
 	serv.ID = 0
 
@@ -562,43 +903,122 @@ func TestRegisterService(t *testing.T) {
 	if err != nil {
 		t.Errorf("Fail Marshal at start of test")
 	}
-	resp = &http.Response{
-		Status:     "200 OK",
-		StatusCode: 200,
-		Header:     http.Header{"Content-Type": []string{"application/json"}},
-		Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+	respFunc = func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+		}
 	}
-	newMockTransport(resp, false, nil)
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Good case when making POST instead
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 0, nil)
+
 	test = RegisterService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) > 0 {
 		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
 	}
-	fmt.Println("Delay is: ", int(test.Seconds()))
 
-	// Bad case: when NewRequest with POST method fails:
-	newMockTransport(resp, false, nil)
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: when NewRequest with POST method fails
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 0, nil)
+
 	registrar.Url = brokenUrl
 	test = RegisterService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since NewRequest with POST method should have failed, got: %d", int(test.Seconds()))
 	}
-	fmt.Println("Delay is: ", int(test.Seconds()))
 
+	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: when http.DefaultClient.Do() fails with a err.Timeout()
+	// -- -- -- -- -- -- -- -- -- -- //
+
 	registrar.Url = "https://leadingregistrar"
 	timeoutErr := timeoutError{}
-	newMockTransport(resp, true, timeoutErr)
+	newMockTransport(respFunc, 1, timeoutErr)
 	test = RegisterService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
 	}
-	fmt.Println("Delay is :", int(test.Seconds()))
 
+	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: when http.DefaultClient.Do() fails but not with a err.Timeout()
-	newMockTransport(resp, true, errHTTP)
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 1, errHTTP)
 	test = RegisterService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
 	}
-	fmt.Println("Delay is :", int(test.Seconds()))
+
+	respFunc = func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(errorReader{}),
+		}
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: when io.ReadAll() returns an error
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 0, nil)
+
+	test = RegisterService(&testSys, mua, serv, registrar)
+	if int(test.Seconds()) != 15 {
+		t.Errorf("Expected the delay to be 15 since the io.ReadAll() call should fail, got %d", int(test.Seconds()))
+	}
+
+	respFunc = func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+		}
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: when Unpack() fails because of a non-existent "Content-Type" in the Header of the response
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 0, nil)
+
+	test = RegisterService(&testSys, mua, serv, registrar)
+	if int(test.Seconds()) != 15 {
+		t.Errorf("Expected the delay to be 15 since the Header had a non-existent/invalid Content-Type, got: %d", int(test.Seconds()))
+	}
+
+	sr.EndOfValidity = ""
+	fakeBody, err = json.Marshal(sr)
+	if err != nil {
+		t.Errorf("Fail Marshal at start of test")
+	}
+	respFunc = func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+		}
+	}
+
+	// -- -- -- -- -- -- -- -- -- -- //
+	// Bad case: Error parsing the EndOfValidity into the RFC3339 time format
+	// -- -- -- -- -- -- -- -- -- -- //
+
+	newMockTransport(respFunc, 0, nil)
+
+	test = RegisterService(&testSys, mua, serv, registrar)
+	if int(test.Seconds()) != 15 {
+		t.Errorf("Expected the delay to be 15 since the EndOfValidity has a faulty time format, got: %d", int(test.Seconds()))
+	}
 }

From 6dfb4155738712502885c957656db9d19feb2bfa Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Fri, 13 Jun 2025 11:25:19 +0200
Subject: [PATCH 034/186] Changed function names

---
 usecases/registration.go      | 16 +++++------
 usecases/registration_test.go | 52 +++++++++++++++++------------------
 2 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index bf45522..d4fa3f5 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -234,12 +234,12 @@ func HandleLeadingRegistrar(sys *components.System, manualTicker time.Duration,
 				select {
 				case <-timer.C:
 					if leadingRegistrar != nil {
-						delay = RegisterService(sys, aResource, service, leadingRegistrar)
+						delay = registerService(sys, aResource, service, leadingRegistrar)
 					} else {
 						delay = 15 * time.Second
 					}
 				case <-sys.Ctx.Done():
-					err := DeregisterService(leadingRegistrar, service)
+					err := deregisterService(leadingRegistrar, service)
 					if err != nil {
 						fmt.Println("Something went wrong with deregistration of service:", err)
 					}
@@ -252,11 +252,11 @@ func HandleLeadingRegistrar(sys *components.System, manualTicker time.Duration,
 }
 
 // registerService makes a POST or PUT request to register or register individual services
-func RegisterService(sys *components.System, ua *components.UnitAsset, serv *components.Service, registrar *components.CoreSystem) (delay time.Duration) {
+func registerService(sys *components.System, ua *components.UnitAsset, serv *components.Service, registrar *components.CoreSystem) (delay time.Duration) {
 
 	delay = 15 * time.Second
 	// Prepare request
-	reqPayload, err := ServiceRegistrationForm(sys, ua, serv, "ServiceRecord_v1")
+	reqPayload, err := serviceRegistrationForm(sys, ua, serv, "ServiceRecord_v1")
 	if err != nil {
 		log.Println("Registration marshall error, ", err)
 		return
@@ -335,7 +335,7 @@ func RegisterService(sys *components.System, ua *components.UnitAsset, serv *com
 }
 
 // deregisterService deletes a service from the database based on its service id
-func DeregisterService(registrar *components.CoreSystem, serv *components.Service) error {
+func deregisterService(registrar *components.CoreSystem, serv *components.Service) error {
 	if registrar == nil {
 		return nil // there is no need to deregister if there is no leading registrar
 	}
@@ -358,7 +358,7 @@ func DeregisterService(registrar *components.CoreSystem, serv *components.Servic
 
 // serviceRegistrationForm returns a json data byte array with the data of the service to be registered
 // in the form of choice [Sending @ Application system]
-func ServiceRegistrationForm(sys *components.System, ua *components.UnitAsset, serv *components.Service, version string) (payload []byte, err error) {
+func serviceRegistrationForm(sys *components.System, ua *components.UnitAsset, serv *components.Service, version string) (payload []byte, err error) {
 	var f forms.Form
 	switch version {
 	case "ServiceRecord_v1":
@@ -376,7 +376,7 @@ func ServiceRegistrationForm(sys *components.System, ua *components.UnitAsset, s
 				sr.ProtoPort[key] = port
 			}
 		}
-		sr.Details = DeepCopyMap((*ua).GetDetails())
+		sr.Details = deepCopyMap((*ua).GetDetails())
 		for key, valueSlice := range serv.Details {
 			sr.Details[key] = append(sr.Details[key], valueSlice...)
 		}
@@ -398,7 +398,7 @@ func ServiceRegistrationForm(sys *components.System, ua *components.UnitAsset, s
 }
 
 // deepCopyMap is necessary to prevent adding values to the original map at every re-registration
-func DeepCopyMap(m map[string][]string) map[string][]string {
+func deepCopyMap(m map[string][]string) map[string][]string {
 	newMap := make(map[string][]string)
 	for k, v := range m {
 		newValue := make([]string, len(v))
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 9e7a76a..c4cd722 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -440,7 +440,7 @@ func TestHandleLeadingRegistrar(t *testing.T) {
 	mua1 := testSys1.UAssets["mockUnitAsset"]
 	serv1 := (*testSys1.UAssets["mockUnitAsset"]).GetServices()["test"]
 
-	payload1, err1 := ServiceRegistrationForm(&testSys1, mua1, serv1, "ServiceRecord_v1")
+	payload1, err1 := serviceRegistrationForm(&testSys1, mua1, serv1, "ServiceRecord_v1")
 
 	if err1 != nil {
 		t.Fatalf("The Service Record version was wrong.")
@@ -498,7 +498,7 @@ func TestHandleLeadingRegistrar(t *testing.T) {
 	mua2 := testSys2.UAssets["mockUnitAsset"]
 	serv2 := (*testSys2.UAssets["mockUnitAsset"]).GetServices()["test"]
 
-	payload2, err2 := ServiceRegistrationForm(&testSys2, mua2, serv2, "ServiceRecord_v1")
+	payload2, err2 := serviceRegistrationForm(&testSys2, mua2, serv2, "ServiceRecord_v1")
 
 	if err2 != nil {
 		t.Fatalf("The Service Record version was wrong.")
@@ -554,7 +554,7 @@ func TestHandleLeadingRegistrar(t *testing.T) {
 	mua3 := testSys3.UAssets["mockUnitAsset"]
 	serv3 := (*testSys3.UAssets["mockUnitAsset"]).GetServices()["test"]
 
-	payload3, err3 := ServiceRegistrationForm(&testSys3, mua3, serv3, "ServiceRecord_v1")
+	payload3, err3 := serviceRegistrationForm(&testSys3, mua3, serv3, "ServiceRecord_v1")
 
 	if err3 != nil {
 		t.Fatalf("The Service Record version was wrong.")
@@ -620,7 +620,7 @@ func TestHandleLeadingRegistrar(t *testing.T) {
 	}
 }
 
-func TestDeepCopyMap(t *testing.T) {
+func TestFordeepCopyMap(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	testSys := createTestSystem(ctx)
@@ -631,7 +631,7 @@ func TestDeepCopyMap(t *testing.T) {
 	// Create a Deep Copy Map of the mockUnitAsset's Details
 	// -- -- -- -- -- -- -- -- -- -- //
 
-	test := DeepCopyMap((*mua).GetDetails())
+	test := deepCopyMap((*mua).GetDetails())
 
 	// -- -- -- -- -- -- -- -- -- -- //
 	// If they are not equal from the beginning then the copy was not successful
@@ -661,7 +661,7 @@ func TestDeepCopyMap(t *testing.T) {
 	}
 }
 
-func TestServiceRegistrationForm(t *testing.T) {
+func TestForserviceRegistrationForm(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	testSys := createTestSystem(ctx)
@@ -673,7 +673,7 @@ func TestServiceRegistrationForm(t *testing.T) {
 	// Call the ServiceRegistrationForm with the correct parameters
 	// -- -- -- -- -- -- -- -- -- -- //
 
-	payload, err := ServiceRegistrationForm(&testSys, mua, serv, version)
+	payload, err := serviceRegistrationForm(&testSys, mua, serv, version)
 
 	// -- -- -- -- -- -- -- -- -- -- //
 	// Check that there was no error in the function (can only be when wrong Service Record version is sent in)
@@ -726,7 +726,7 @@ func TestServiceRegistrationForm(t *testing.T) {
 	// -- -- -- -- -- -- -- -- -- -- //
 
 	version = "UnknownVersion"
-	_, err = ServiceRegistrationForm(&testSys, mua, serv, version)
+	_, err = serviceRegistrationForm(&testSys, mua, serv, version)
 	if err == nil {
 		t.Fatal("expected error for unsupported version, got nil")
 	}
@@ -740,7 +740,7 @@ func TestServiceRegistrationForm(t *testing.T) {
 
 	(*testSys.UAssets["mockUnitAsset"]).GetServices()["test"].RegPeriod = 0
 	version = "ServiceRecord_v1"
-	payload, err = ServiceRegistrationForm(&testSys, mua, serv, version)
+	payload, err = serviceRegistrationForm(&testSys, mua, serv, version)
 	if err != nil {
 		t.Fatalf("The Service Record version was wrong.")
 	}
@@ -753,7 +753,7 @@ func TestServiceRegistrationForm(t *testing.T) {
 	}
 }
 
-func TestDeregisterService(t *testing.T) {
+func TestForderegisterService(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	testSys := createTestSystem(ctx)
@@ -775,7 +775,7 @@ func TestDeregisterService(t *testing.T) {
 
 	newMockTransport(respFunc, 0, nil)
 
-	err := DeregisterService(registrar, serv)
+	err := deregisterService(registrar, serv)
 	if err != nil {
 		t.Errorf("Expected error: %v, got: %v", nil, err)
 	}
@@ -786,7 +786,7 @@ func TestDeregisterService(t *testing.T) {
 
 	registrar = testSys.CoreS[1]
 
-	err = DeregisterService(registrar, serv)
+	err = deregisterService(registrar, serv)
 	if err != nil {
 		t.Errorf("Expected error: %v, got: %v", nil, err)
 	}
@@ -796,7 +796,7 @@ func TestDeregisterService(t *testing.T) {
 	// -- -- -- -- -- -- -- -- -- -- //
 
 	newMockTransport(respFunc, 1, errHTTP)
-	err = DeregisterService(registrar, serv)
+	err = deregisterService(registrar, serv)
 	if err == nil {
 		t.Errorf("Expected error while sending http request")
 	}
@@ -807,7 +807,7 @@ func TestDeregisterService(t *testing.T) {
 
 	newMockTransport(respFunc, 0, nil)
 	registrar.Url = brokenUrl
-	err = DeregisterService(registrar, serv)
+	err = deregisterService(registrar, serv)
 	if err == nil {
 		t.Errorf("Expected error while creating http request")
 	}
@@ -828,7 +828,7 @@ func TestServiceRegistrationFormList(t *testing.T) {
 	}
 }
 
-func TestRegisterService(t *testing.T) {
+func TestForregisterService(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	testSys := createTestSystem(ctx)
@@ -836,7 +836,7 @@ func TestRegisterService(t *testing.T) {
 	serv := (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"]
 	registrar := testSys.CoreS[1]
 
-	payload, err := ServiceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
+	payload, err := serviceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
 
 	if err != nil {
 		t.Fatalf("The Service Record version was wrong.")
@@ -868,7 +868,7 @@ func TestRegisterService(t *testing.T) {
 
 	newMockTransport(respFunc, 0, nil)
 
-	test := RegisterService(&testSys, mua, serv, registrar)
+	test := registerService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) > 0 {
 		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
 	}
@@ -879,7 +879,7 @@ func TestRegisterService(t *testing.T) {
 
 	newMockTransport(respFunc, 0, nil)
 	registrar.Url = brokenUrl
-	test = RegisterService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since NewRequest with PUT method should have failed, got: %d", int(test.Seconds()))
 	}
@@ -887,7 +887,7 @@ func TestRegisterService(t *testing.T) {
 	registrar.Url = "https://leadingregistrar"
 	serv.ID = 0
 
-	payload, err = ServiceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
+	payload, err = serviceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
 
 	if err != nil {
 		t.Fatalf("The Service Record version was wrong.")
@@ -918,7 +918,7 @@ func TestRegisterService(t *testing.T) {
 
 	newMockTransport(respFunc, 0, nil)
 
-	test = RegisterService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) > 0 {
 		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
 	}
@@ -930,7 +930,7 @@ func TestRegisterService(t *testing.T) {
 	newMockTransport(respFunc, 0, nil)
 
 	registrar.Url = brokenUrl
-	test = RegisterService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since NewRequest with POST method should have failed, got: %d", int(test.Seconds()))
 	}
@@ -942,7 +942,7 @@ func TestRegisterService(t *testing.T) {
 	registrar.Url = "https://leadingregistrar"
 	timeoutErr := timeoutError{}
 	newMockTransport(respFunc, 1, timeoutErr)
-	test = RegisterService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
 	}
@@ -952,7 +952,7 @@ func TestRegisterService(t *testing.T) {
 	// -- -- -- -- -- -- -- -- -- -- //
 
 	newMockTransport(respFunc, 1, errHTTP)
-	test = RegisterService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
 	}
@@ -972,7 +972,7 @@ func TestRegisterService(t *testing.T) {
 
 	newMockTransport(respFunc, 0, nil)
 
-	test = RegisterService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the io.ReadAll() call should fail, got %d", int(test.Seconds()))
 	}
@@ -992,7 +992,7 @@ func TestRegisterService(t *testing.T) {
 
 	newMockTransport(respFunc, 0, nil)
 
-	test = RegisterService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the Header had a non-existent/invalid Content-Type, got: %d", int(test.Seconds()))
 	}
@@ -1017,7 +1017,7 @@ func TestRegisterService(t *testing.T) {
 
 	newMockTransport(respFunc, 0, nil)
 
-	test = RegisterService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, mua, serv, registrar)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the EndOfValidity has a faulty time format, got: %d", int(test.Seconds()))
 	}

From e865e5e1f49dacc41da672e50b68baeda57be4e6 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 13 Jun 2025 11:31:45 +0200
Subject: [PATCH 035/186] Optimised GH workflow to minimise spent time

---
 .github/workflows/main.yml | 6 ++++--
 Makefile                   | 4 +++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 4cd3683..e365fbd 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -2,6 +2,8 @@ name: Linters, Spellcheck, and Tests
 
 on:
   push:
+    paths:
+      - '**.go'
   workflow_dispatch:
 
 jobs:
@@ -15,7 +17,7 @@ jobs:
         with:
           go-version: 1.23
       - name: Install dependencies
-        run: make deps
+        run: make linterinstall
       - name: Run linters
         run: make lint
 
@@ -36,7 +38,7 @@ jobs:
         with:
           go-version: 1.23
       - name: Install dependencies
-        run: make deps
+        run: make modinstall
       - name: Run tests
         run: make test
       - name: Report stats
diff --git a/Makefile b/Makefile
index ece9093..a4284c6 100644
--- a/Makefile
+++ b/Makefile
@@ -25,8 +25,10 @@ analyse:
 	gocyclo -avg -top 10 -ignore test.go .
 
 # Updates 3rd party packages and tools
-deps:
+modinstall:
 	go mod download
+
+linterinstall:
 	go install github.com/securego/gosec/v2/cmd/gosec@latest
 	go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
 	go install code.larus.se/lmas/pointerinterface@latest

From fea8222785dca3dd2236f23a604c4856061c94eb Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 13 Jun 2025 11:40:06 +0200
Subject: [PATCH 036/186] Fix missing tool

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index a4284c6..b4fb796 100644
--- a/Makefile
+++ b/Makefile
@@ -27,10 +27,10 @@ analyse:
 # Updates 3rd party packages and tools
 modinstall:
 	go mod download
+	go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
 
 linterinstall:
 	go install github.com/securego/gosec/v2/cmd/gosec@latest
-	go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
 	go install code.larus.se/lmas/pointerinterface@latest
 
 # Clean up built binary and other temporary files (ignores errors from rm)

From 7b8a0b4187e083576e0b7034398537beeda01ded Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 13 Jun 2025 14:20:01 +0200
Subject: [PATCH 037/186] Adds makefile helper to run all checks

---
 Makefile | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Makefile b/Makefile
index b4fb796..39e4531 100644
--- a/Makefile
+++ b/Makefile
@@ -16,6 +16,9 @@ lint:
 spellcheck:
 	typos .
 
+# All in one check
+runchecks: test lint spellcheck
+	
 # Generate pretty coverage report
 analyse:
 	go tool cover -html=".cover.out" -o="cover.html"

From feab5b889c9ac5e8b996ea99e852c856a21634c7 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Fri, 13 Jun 2025 17:08:16 +0200
Subject: [PATCH 038/186] Simplified the sendHttpReq() test

---
 usecases/serviceDiscovery_test.go | 96 +++++++++++++++++++------------
 1 file changed, 60 insertions(+), 36 deletions(-)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 678f954..4350bc7 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -200,7 +200,7 @@ func createTestData(bodyType string, proto int, version string, errRead bool) (d
 	}
 }
 
-type params struct {
+type ExtractQuestFormParams struct {
 	testCase      string
 	bodyType      string
 	protocol      int
@@ -211,8 +211,9 @@ type params struct {
 
 func TestExtractQuestForm(t *testing.T) {
 	// A list holding structs containing the parameters used for the test
-	testParams := []params{
-		// {"testCase", "bodyType", "protocol", "version", "errRead", "expectedError"}
+	testParams := []ExtractQuestFormParams{
+		// {testCase, bodyType, protocol, version, errRead, expectedError}
+		// Always start with the "Best case, no errors"
 		{"No errors", "testBodyHasVersion", -1, "ServiceQuest_v1", false, false},
 		{"Error during Unmarshal", "testBodyHasVersion", -1, "ServiceQuest_v1", true, true},
 		{"Missing version", "testBodyNoVersion", -1, "", false, false},
@@ -269,47 +270,70 @@ func (errReader) Close() error {
 
 var brokenUrl = string([]byte{0x7f})
 
-// sendHttpReq(method string, url string, jsonQF []byte, ctx context.Context) (resp *http.Response, err error)
-func TestSendHttpReq(t *testing.T) {
-	// Good case: everything passes
-	resp := &http.Response{
+type SendHttpReqParams struct {
+	testCase    string
+	method      string
+	url         string
+	data        []byte
+	ctx         context.Context
+	respError   bool
+	expectError bool
+}
+
+func testSystemSetup() (resp *http.Response, data []byte, ctx context.Context, cancel context.CancelFunc, err error) {
+	ctx, cancel = context.WithCancel(context.Background())
+	var form forms.ServiceQuest_v1
+	form.NewForm()
+	resp = &http.Response{
 		Status:     "200 OK",
 		StatusCode: 200,
 		Body:       io.NopCloser(strings.NewReader(string("test body"))),
 	}
-	newMockTransport(resp, 0, nil)
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	var qForm forms.ServiceQuest_v1
-	qForm.NewForm()
-	jsonQF, err := json.MarshalIndent(qForm, "", "  ")
-	if err != nil {
-		t.Errorf("Error occurred while Marshalling in test: %v", err)
-	}
-	_, err = sendHttpReq(http.MethodPost, "https://test", jsonQF, ctx)
+	data, err = json.MarshalIndent(form, "", "  ")
 	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-	cancel()
-
-	// Bad case: url broken, cant make request
-	ctx, cancel = context.WithCancel(context.Background())
-	qForm.NewForm()
-	_, err = sendHttpReq(http.MethodPost, brokenUrl, jsonQF, ctx)
-	if err == nil {
-		t.Errorf("Expected errors while sending http request")
+		return nil, nil, ctx, cancel, errors.New("---\tError occurred while marshalling in test system setup")
 	}
-	cancel()
+	return
+}
 
-	// Bad case: response returns error
-	newMockTransport(resp, 1, errHTTP)
-	ctx, cancel = context.WithCancel(context.Background())
-	qForm.NewForm()
-	_, err = sendHttpReq(http.MethodPost, "https://test", jsonQF, ctx)
-	if err == nil {
-		t.Errorf("Expected errors while sending http request")
+func TestSendHttpReq(t *testing.T) {
+	resp, data, ctx, cancel, err := testSystemSetup()
+	defer cancel()
+	newMockTransport(resp, 0, nil)
+	if err != nil {
+		t.Errorf("Error occurred while starting test system: %e", err)
+	}
+	params := []SendHttpReqParams{
+		// {testCase, method, url, data, ctx, respError, expectError}
+		// Always start with the "Best case, no errors"
+		{"No errors", http.MethodPost, "http://test", data, ctx, false, false},
+		{"Error creating new request", http.MethodPost, brokenUrl, data, ctx, false, true},
+		{"DefaultClient returns error", http.MethodPost, "http://test", data, ctx, true, true},
+	}
+	var lastLoopErr bool
+	for _, c := range params {
+		// Make sure the the mockTransport doesn't return an error unless needed by the test
+		if (lastLoopErr == true) && (c.respError == false) {
+			newMockTransport(resp, 0, nil)
+			lastLoopErr = false
+		}
+		// Make a new mockTransport with an error response if the test needs it
+		if (lastLoopErr == false) && (c.respError == true) {
+			newMockTransport(resp, 1, errHTTP)
+			lastLoopErr = true
+		}
+		// Run the test
+		_, err = sendHttpReq(c.method, c.url, c.data, c.ctx)
+		if c.expectError == false {
+			if err != nil {
+				t.Errorf("Unexpected error in '%s' test case: %e", c.testCase, err)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("Expected error in '%s' test case, got none", c.testCase)
+			}
+		}
 	}
-	cancel()
 }
 
 func TestSearch4Service(t *testing.T) {

From c038baf7dd12c10383f00358dfeefadb306d11a2 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 16 Jun 2025 09:32:10 +0200
Subject: [PATCH 039/186] Added an error for wrong statuscode of response

---
 usecases/serviceDiscovery.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/usecases/serviceDiscovery.go b/usecases/serviceDiscovery.go
index daa8cf8..3c1cd7a 100644
--- a/usecases/serviceDiscovery.go
+++ b/usecases/serviceDiscovery.go
@@ -98,7 +98,6 @@ func sendHttpReq(method string, url string, data []byte, ctx context.Context) (r
 
 // Search4Service requests from the core systems the address of resources's services that meet the need
 func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocation forms.ServicePoint_v1, err error) {
-
 	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) // Create a new context, with a 2-second timeout
 	defer cancel()
 
@@ -119,8 +118,11 @@ func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocat
 	if err != nil {
 		return servLocation, err
 	}
-
 	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return servLocation, fmt.Errorf("received non-2xx status code: %d, response: %s from the Orchestrator", resp.StatusCode, http.StatusText(resp.StatusCode))
+	}
+
 	// Read the response /////////////////////////////////
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {

From 85ce2e076198f07624f7af01c3f97d9f03cbcb50 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 16 Jun 2025 09:33:04 +0200
Subject: [PATCH 040/186] Added test for wrong statuscode of response from
 sendHttpReq()

---
 usecases/serviceDiscovery_test.go | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 4350bc7..b984028 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -384,7 +384,19 @@ func TestSearch4Service(t *testing.T) {
 	qForm.NewForm()
 	_, err = Search4Service(qForm, &testSys)
 	if err == nil {
-		t.Errorf("Expected error at GetRunningCoreSystemURL()")
+		t.Errorf("Expected error at sendHttpRequest()")
+	}
+	cancel()
+
+	// Non-2xx status code of response from sendHttpRequest()
+	resp.StatusCode = 300
+	newMockTransport(resp, 0, nil)
+	ctx, cancel = context.WithCancel(context.Background())
+	testSys = createTestSystem(ctx, false)
+	qForm.NewForm()
+	_, err = Search4Service(qForm, &testSys)
+	if err == nil {
+		t.Errorf("Expected error at sendHttpRequest")
 	}
 	cancel()
 

From 1b4eddafaf4700eac1242abb8cc4a7298523014f Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 16 Jun 2025 09:35:58 +0200
Subject: [PATCH 041/186] Changed back statuscode for tests following 'Non-2xx
 status code' test case

---
 usecases/serviceDiscovery_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index b984028..64d1984 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -401,6 +401,7 @@ func TestSearch4Service(t *testing.T) {
 	cancel()
 
 	// Error at "Read the response", io.ReadAll()
+	resp.StatusCode = 200
 	f = createServicePointTestForm()
 	resp.Body = errReader(0)
 	newMockTransport(resp, 0, nil)

From b5fc92145f38f7b7eb4d0f61d8115f0b45b6cdb6 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 16 Jun 2025 10:32:43 +0200
Subject: [PATCH 042/186] Made table driven tests for confirmLeadingRegistrar
 and findLeadingRegistrar

---
 usecases/registration.go      |   2 +-
 usecases/registration_test.go | 527 +++++++---------------------------
 2 files changed, 107 insertions(+), 422 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index 894ac58..ba755b0 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -137,7 +137,7 @@ func findLeadingRegistrar(sys *components.System, leadingRegistrar *components.C
 			fmt.Println("Error closing service registrar response body:", errClose)
 		}
 		if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
-			fmt.Printf("\nlead registrar found at: %s\n", leadingRegistrar.Url)
+			fmt.Printf("\nlead registrar found at: %s\n", core.Url)
 			return core
 		}
 	}
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 26f9fe7..c293998 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -173,454 +173,139 @@ func createTestSystem(ctx context.Context) components.System {
 	return sys
 }
 
-/*
-func TestDiscoverLeadingRegistrar(t *testing.T) {
-	// Create a new Test System to run the test on
-	ctx1, cancel1 := context.WithCancel(context.Background())
-	defer cancel1()
-	testSys1 := createTestSystem(ctx1)
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Good case: Everything works in the case that there is no immediate leading registrar
-	// -- -- -- -- -- -- -- -- -- -- //
+type confirmLeadingRegistrarParams struct {
+	testCase         string
+	mockTransportErr int
+	errHTTP          error
+	expectedOutput   *components.CoreSystem
+}
 
-	respFunc1 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
+func createTestBody(testCase string) (respFunc func() *http.Response) {
+	if testCase == "No errors" {
+		respFunc := func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
+			}
 		}
-	}
-	newMockTransport(respFunc1, 0, nil)
-
-	manualTicker := 10 * time.Millisecond
-
-	resultCh1 := make(chan *components.CoreSystem, 1)
-	defer close(resultCh1)
-	go func() {
-		res1 := DiscoverLeadingRegistrar(&testSys1, manualTicker, false)
-		resultCh1 <- res1
-	}()
-	time.Sleep(5 * manualTicker)
-	cancel1()
-	leadReg1 := <-resultCh1
-	if leadReg1.Name != "serviceregistrar" {
-		t.Errorf("Expected %s, got: %s", "serviceregistrar", leadReg1.Name)
-	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Bad case: Broken URL
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx2, cancel2 := context.WithCancel(context.Background())
-	defer cancel2()
-	testSys2 := createTestSystem(ctx2)
-
-	respFunc2 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
+		return respFunc
+	}
+	if testCase == "Read error" {
+		respFunc := func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(errorReader{}),
+			}
 		}
-	}
-
-	newMockTransport(respFunc2, 0, nil)
-	testSys2.CoreS[1].Url = brokenUrl
-	resultCh2 := make(chan *components.CoreSystem, 1)
-	defer close(resultCh2)
-	go func() {
-		res2 := DiscoverLeadingRegistrar(&testSys2, manualTicker, false)
-		resultCh2 <- res2
-	}()
-	time.Sleep(5 * manualTicker)
-	cancel2()
-	leadReg2 := <-resultCh2
-	if leadReg2 != nil {
-		t.Errorf("Expected the leading registrar to be nil, got: %v", leadReg2)
-	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Bad case: io.ReadAll() returns an error
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx3, cancel3 := context.WithCancel(context.Background())
-	defer cancel3()
-	testSys3 := createTestSystem(ctx3)
-
-	respFunc3 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(errorReader{}),
+		return respFunc
+	}
+	if testCase == "Prefix error" {
+		respFunc := func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string("Wrong prefix"))),
+			}
 		}
-	}
-
-	newMockTransport(respFunc3, 0, nil)
-	resultCh3 := make(chan *components.CoreSystem, 1)
-	defer close(resultCh3)
-	go func() {
-		res3 := DiscoverLeadingRegistrar(&testSys3, manualTicker, false)
-		resultCh3 <- res3
-	}()
-	time.Sleep(5 * manualTicker)
-	cancel3()
-	leadReg3 := <-resultCh3
-	if leadReg3 != nil {
-		t.Errorf("Expected an error when reading the response body, got: %v", leadReg3)
-	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Bad case: Closing the response body returns an error (no real way to see this as the error handling for that does nothing)
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx4, cancel4 := context.WithCancel(context.Background())
-	defer cancel4()
-	testSys4 := createTestSystem(ctx4)
-
-	respFunc4 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       &errorReadCloser{},
+		return respFunc
+	}
+	if testCase == "Broken URL" {
+		respFunc := func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
+			}
 		}
+		return respFunc
 	}
+	return nil
+}
 
-	newMockTransport(respFunc4, 0, nil)
-	resultCh4 := make(chan *components.CoreSystem, 1)
-	defer close(resultCh4)
-	go func() {
-		res4 := DiscoverLeadingRegistrar(&testSys4, manualTicker, false)
-		resultCh4 <- res4
-	}()
-	time.Sleep(5 * manualTicker)
-	cancel4()
-	leadReg4 := <-resultCh4
-	if leadReg4 != nil {
-		t.Errorf("Expected an error when closing the response body, got: %v", leadReg4)
-	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Good case: But the leading registrar is not null in the beginning
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx5, cancel5 := context.WithCancel(context.Background())
-	defer cancel5()
-	testSys5 := createTestSystem(ctx5)
-
-	respFunc5 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
-		}
-	}
+func TestForconfirmLeadingRegistrar(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
 
-	newMockTransport(respFunc5, 0, nil)
-	resultCh5 := make(chan *components.CoreSystem, 1)
-	defer close(resultCh5)
-	go func() {
-		res5 := DiscoverLeadingRegistrar(&testSys5, manualTicker, true)
-		resultCh5 <- res5
-	}()
-	time.Sleep(5 * manualTicker)
-	cancel5()
-	leadReg5 := <-resultCh5
-	if leadReg5.Name != "serviceregistrar" {
-		t.Errorf("Expected the lead registrars name to be: %s, got: %s", "serviceregistrar", leadReg5.Name)
+	testParams := []confirmLeadingRegistrarParams{
+		{"No errors", 0, nil, testSys.CoreS[1]},
+		{"Read error", 0, nil, nil},
+		{"Prefix error", 0, nil, nil},
+		{"Broken URL", 0, nil, nil},
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Bad case: Broken URL, with leading registrar from the beginning
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx6, cancel6 := context.WithCancel(context.Background())
-	defer cancel6()
-	testSys6 := createTestSystem(ctx6)
-
-	respFunc6 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
+	for _, test := range testParams {
+		respFunc := createTestBody(test.testCase)
+		if respFunc == nil {
+			t.Errorf("---\tError occurred while creating test data")
 		}
-	}
-
-	newMockTransport(respFunc6, 0, nil)
-	testSys6.CoreS[1].Url = brokenUrl
-	resultCh6 := make(chan *components.CoreSystem, 1)
-	defer close(resultCh6)
-	go func() {
-		res6 := DiscoverLeadingRegistrar(&testSys6, manualTicker, true)
-		resultCh6 <- res6
-	}()
-	time.Sleep(5 * manualTicker)
-	cancel6()
-	leadReg6 := <-resultCh6
-	if leadReg6 != nil {
-		t.Errorf("Expected leading registrar to be nil since broken URL in Get() method, got: %v", leadReg6)
-	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Bad case: io.ReadAll() returns an error, with leading registrar from the beginning
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx7, cancel7 := context.WithCancel(context.Background())
-	defer cancel7()
-	testSys7 := createTestSystem(ctx7)
-
-	respFunc7 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(errorReader{}),
+		newMockTransport(respFunc, test.mockTransportErr, test.errHTTP)
+		if test.testCase == "Broken URL" {
+			testSys.CoreS[1].Url = brokenUrl
 		}
-	}
-
-	newMockTransport(respFunc7, 0, nil)
-	resultCh7 := make(chan *components.CoreSystem, 1)
-	defer close(resultCh7)
-	go func() {
-		res7 := DiscoverLeadingRegistrar(&testSys7, manualTicker, true)
-		resultCh7 <- res7
-	}()
-	time.Sleep(5 * manualTicker)
-	cancel7()
-	leadReg7 := <-resultCh7
-	if leadReg7 != nil {
-		t.Errorf("Expected an error when reading the response body, got: %v", leadReg7)
-	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Bad case: The previous leading registrar has been lost. i.e. Prefix in bodyBytes string is not "lead Service Registrar since", with leading registrar from the beginning
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx8, cancel8 := context.WithCancel(context.Background())
-	defer cancel8()
-	testSys8 := createTestSystem(ctx8)
 
-	respFunc8 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(""))),
+		// Do the test
+		res := confirmLeadingRegistrar(testSys.CoreS[1])
+		if test.testCase == "No errors" {
+			if res != test.expectedOutput {
+				t.Errorf("Test case: %s got error: %v", test.testCase, res)
+			}
+		} else {
+			if res != test.expectedOutput {
+				t.Errorf("---\tTest case: expected leading registrar to be nil, got: %v", res)
+			}
 		}
 	}
-
-	newMockTransport(respFunc8, 0, nil)
-	resultCh8 := make(chan *components.CoreSystem, 1)
-	defer close(resultCh8)
-	go func() {
-		res8 := DiscoverLeadingRegistrar(&testSys8, manualTicker, true)
-		resultCh8 <- res8
-	}()
-	time.Sleep(5 * manualTicker)
-	cancel8()
-	leadReg8 := <-resultCh8
-	if leadReg8 != nil {
-		t.Errorf("Expected the lead registrar to be nil since it is lost, got: %s", leadReg8)
-	}
 }
 
-func TestHandleLeadingRegistrar(t *testing.T) {
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Good case, everything works, the system has UnitAssets
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx1, cancel1 := context.WithCancel(context.Background())
-	defer cancel1()
-	testSys1 := createTestSystem(ctx1)
-	mua1 := testSys1.UAssets["mockUnitAsset"]
-	serv1 := (*testSys1.UAssets["mockUnitAsset"]).GetServices()["test"]
-
-	payload1, err1 := serviceRegistrationForm(&testSys1, mua1, serv1, "ServiceRecord_v1")
-
-	if err1 != nil {
-		t.Fatalf("The Service Record version was wrong.")
-	}
-
-	var sr1 forms.ServiceRecord_v1
-	if err := json.Unmarshal(payload1, &sr1); err != nil {
-		t.Fatalf("Invalid JSON: %v", err)
-	}
+type findLeadingRegistrarParams struct {
+	testCase         string
+	mockTransportErr int
+	errHTTP          error
+	expectedOutput   *components.CoreSystem
+}
 
-	sr1.EndOfValidity = time.Now().Format(time.RFC3339)
+func TestForfindLeadingRegistrar(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	testSys := createTestSystem(ctx)
 
-	fakeBody1, err := json.Marshal(sr1)
-	if err != nil {
-		t.Errorf("Fail Marshal at start of test")
+	testParams := []findLeadingRegistrarParams{
+		{"No errors", 0, nil, testSys.CoreS[1]},
+		{"Read error", 0, nil, nil},
+		{"Prefix error", 0, nil, nil},
+		{"Broken URL", 0, nil, nil},
 	}
 
-	respFunc1 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(fakeBody1))),
+	for _, test := range testParams {
+		respFunc := createTestBody(test.testCase)
+		if respFunc == nil {
+			t.Errorf("---\tError occurred while creating test data")
 		}
-	}
-	newMockTransport(respFunc1, 0, nil)
-
-	manualTicker := 50 * time.Millisecond
-	resultTest1 := make(chan time.Duration, 1)
-	resultErr1 := make(chan error, 1)
-
-	go func() {
-		dur1, err1 := HandleLeadingRegistrar(&testSys1, manualTicker, false)
-		resultTest1 <- dur1
-		resultErr1 <- err1
-	}()
-	time.Sleep(100 * time.Millisecond)
-	cancel1()
-	res1 := <-resultTest1
-	resErr1 := <-resultErr1
-	if int(res1.Seconds()) != 15 {
-		t.Errorf("Expected the delay to be 15 seconds since there is no leading registrar, got: %d", int(res1.Seconds()))
-	}
-	if resErr1 != nil {
-		t.Errorf("Expected the error to be nil since there is no need to deregister a service that is not registered, got: %v", err)
-	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Good case, when leading registrar is not null in the beginning
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx2, cancel2 := context.WithCancel(context.Background())
-	defer cancel2()
-	testSys2 := createTestSystem(ctx2)
-	mua2 := testSys2.UAssets["mockUnitAsset"]
-	serv2 := (*testSys2.UAssets["mockUnitAsset"]).GetServices()["test"]
-
-	payload2, err2 := serviceRegistrationForm(&testSys2, mua2, serv2, "ServiceRecord_v1")
-
-	if err2 != nil {
-		t.Fatalf("The Service Record version was wrong.")
-	}
-
-	var sr2 forms.ServiceRecord_v1
-	if err = json.Unmarshal(payload2, &sr2); err != nil {
-		t.Fatalf("Invalid JSON: %v", err)
-	}
-
-	sr2.EndOfValidity = time.Now().Format(time.RFC3339)
-
-	fakeBody2, err := json.Marshal(sr2)
-	if err != nil {
-		t.Errorf("Fail Marshal at start of test")
-	}
-
-	respFunc2 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(fakeBody2))),
+		newMockTransport(respFunc, test.mockTransportErr, test.errHTTP)
+		if test.testCase == "Broken URL" {
+			testSys.CoreS[1].Url = brokenUrl
 		}
-	}
-
-	newMockTransport(respFunc2, 0, nil)
-	resultTest2 := make(chan time.Duration, 1)
-	resultErr2 := make(chan error, 1)
-	go func() {
-		dur2, err2 := HandleLeadingRegistrar(&testSys2, manualTicker, true)
-		resultTest2 <- dur2
-		resultErr2 <- err2
-	}()
-	time.Sleep(100 * time.Millisecond)
-	cancel2()
-	res2 := <-resultTest2
-	resErr2 := <-resultErr2
-	if int(res2.Seconds()) > 0 {
-		t.Errorf("Expected the delay to be negative since the service should have been registered, got: %d", int(res2.Seconds()))
-	}
-	if resErr2 != nil {
-		t.Errorf("Expected the service to be able to deregistered, got: %v", err)
-	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Bad case, error when deregistring the service
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx3, cancel3 := context.WithCancel(context.Background())
-	defer cancel3()
-	testSys3 := createTestSystem(ctx3)
-	mua3 := testSys3.UAssets["mockUnitAsset"]
-	serv3 := (*testSys3.UAssets["mockUnitAsset"]).GetServices()["test"]
-
-	payload3, err3 := serviceRegistrationForm(&testSys3, mua3, serv3, "ServiceRecord_v1")
-
-	if err3 != nil {
-		t.Fatalf("The Service Record version was wrong.")
-	}
-
-	var sr3 forms.ServiceRecord_v1
-	if err = json.Unmarshal(payload3, &sr3); err != nil {
-		t.Fatalf("Invalid JSON: %v", err)
-	}
-
-	sr3.EndOfValidity = time.Now().Format(time.RFC3339)
 
-	fakeBody3, err := json.Marshal(sr3)
-	if err != nil {
-		t.Errorf("Fail Marshal at start of test")
-	}
-
-	respFunc3 := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(fakeBody3))),
+		// Do the test
+		res := findLeadingRegistrar(&testSys, nil)
+		if test.testCase == "No errors" {
+			if res != test.expectedOutput {
+				t.Errorf("Test case: %s got error: %v", test.testCase, res)
+			}
+		} else {
+			if res != test.expectedOutput {
+				t.Errorf("---\tTest case: expected leading registrar to be nil, got: %v", res)
+			}
 		}
 	}
-
-	newMockTransport(respFunc3, 1, errHTTP)
-	resultTest3 := make(chan time.Duration, 1)
-	resultErr3 := make(chan error, 1)
-	go func() {
-		dur3, err3 := HandleLeadingRegistrar(&testSys3, manualTicker, true)
-		resultTest3 <- dur3
-		resultErr3 <- err3
-	}()
-	time.Sleep(100 * time.Millisecond)
-	cancel3()
-	resErr3 := <-resultErr3
-	if resErr3 == nil {
-		t.Errorf("Expected an error when deregistring the service, got: %v", resErr3)
-	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
-	// Neutral case, the system has no UAssets so it won't either register or deregister anything
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	ctx4, cancel4 := context.WithCancel(context.Background())
-	defer cancel4()
-	testSys4 := createTestSystem(ctx4)
-	testSys4.UAssets = nil
-
-	resultTest4 := make(chan time.Duration, 1)
-	resultErr4 := make(chan error, 1)
-	go func() {
-		dur4, err4 := HandleLeadingRegistrar(&testSys4, manualTicker, true)
-		resultTest4 <- dur4
-		resultErr4 <- err4
-	}()
-	time.Sleep(100 * time.Millisecond)
-	cancel4()
-	res4 := <-resultTest4
-	if res4 != 0 {
-		t.Errorf("Expected the delay to be 0 (time.Duration zero value) since the system has no UAssets, got: %d", int(res4.Seconds()))
-	}
 }
-*/
 
 func TestFordeepCopyMap(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())

From b31dce2b292e82a0e7261222d3f236f46eade51e Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 16 Jun 2025 14:14:23 +0200
Subject: [PATCH 043/186] Added a file containing test functions and removed
 sample_test.go

---
 usecases/sample_test.go |  35 ---------
 usecases/utils_test.go  | 164 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 164 insertions(+), 35 deletions(-)
 delete mode 100644 usecases/sample_test.go
 create mode 100644 usecases/utils_test.go

diff --git a/usecases/sample_test.go b/usecases/sample_test.go
deleted file mode 100644
index a117a15..0000000
--- a/usecases/sample_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package usecases
-
-import (
-	"testing"
-)
-
-/*
-// mockTransport is used for replacing the default network Transport (used by
-// http.DefaultClient) and it will intercept network requests.
-
-	type mockTransport struct {
-		resp *http.Response
-	}
-
-	func newMockTransport(resp *http.Response) mockTransport {
-		t := mockTransport{
-			resp: resp,
-		}
-		// Hijack the default http client so no actual http requests are sent over the network
-		http.DefaultClient.Transport = t
-		return t
-	}
-
-// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
-// It prevents the request from being sent over the network and count how many times
-// a domain was requested.
-
-	func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-		t.resp.Request = req
-		return t.resp, nil
-	}
-*/
-func TestSample(t *testing.T) {
-	return
-}
diff --git a/usecases/utils_test.go b/usecases/utils_test.go
new file mode 100644
index 0000000..69409b8
--- /dev/null
+++ b/usecases/utils_test.go
@@ -0,0 +1,164 @@
+package usecases
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/sdoque/mbaigo/components"
+)
+
+// mockTransport is used for replacing the default network Transport (used by
+// http.DefaultClient) and it will intercept network requests.
+type mockTransport struct {
+	respFunc func() *http.Response
+	hits     int
+	err      error
+}
+
+func newMockTransport(respFunc func() *http.Response, v int, err error) mockTransport {
+	t := mockTransport{
+		respFunc: respFunc,
+		hits:     v,
+		err:      err,
+	}
+	// Hijack the default http client so no actual http requests are sent over the network
+	http.DefaultClient.Transport = t
+	return t
+}
+
+// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
+// It prevents the request from being sent over the network, and count how many times
+// a http request was sent
+func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	t.hits -= 1
+	//log.Printf("hits: %d", t.hits)
+	if t.hits == 0 {
+		return nil, t.err
+	}
+	resp = t.respFunc()
+	resp.Request = req
+	return resp, nil
+}
+
+// A mocked UnitAsset used for testing
+type mockUnitAsset struct {
+	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
+	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
+	Details     map[string][]string `json:"details"` // Metadata or details about this UA
+	ServicesMap components.Services `json:"-"`
+	CervicesMap components.Cervices `json:"-"`
+}
+
+func (mua mockUnitAsset) GetName() string {
+	return mua.Name
+}
+
+func (mua mockUnitAsset) GetServices() components.Services {
+	return mua.ServicesMap
+}
+
+func (mua mockUnitAsset) GetCervices() components.Cervices {
+	return mua.CervicesMap
+}
+
+func (mua mockUnitAsset) GetDetails() map[string][]string {
+	return mua.Details
+}
+
+func (mua mockUnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {}
+
+// Create a error reader to break json.Unmarshal()
+type errReader int
+
+var errBodyRead error = fmt.Errorf("bad body read")
+
+func (errReader) Read(p []byte) (n int, err error) {
+	return 0, errBodyRead
+}
+func (errReader) Close() error {
+	return nil
+}
+
+// Variables used in testing
+var brokenUrl = string([]byte{0x7f})
+var errHTTP error = fmt.Errorf("bad http request")
+
+// Help function to create a test system
+func createTestSystem(ctx context.Context, broken bool) components.System {
+	// instantiate the System
+	sys := components.NewSystem("testSystem", ctx)
+
+	// Instantiate the Capsule
+	sys.Husk = &components.Husk{
+		Description: "A test system",
+		Details:     map[string][]string{"Developer": {"Test dev"}},
+		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
+		InfoLink:    "https://for.testing.purposes",
+	}
+
+	// create fake services and cervices for a mocked unit asset
+	testCerv := &components.Cervice{
+		Definition: "testCerv",
+		Details:    map[string][]string{"Forms": {"SignalA_v1a"}},
+		Nodes:      map[string][]string{},
+	}
+
+	CervicesMap := &components.Cervices{
+		testCerv.Definition: testCerv,
+	}
+	setTest := &components.Service{
+		ID:            1,
+		Definition:    "test",
+		SubPath:       "test",
+		Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+		Description:   "A test service",
+		RegPeriod:     45,
+		RegTimestamp:  "now",
+		RegExpiration: "45",
+	}
+	ServicesMap := &components.Services{
+		setTest.SubPath: setTest,
+	}
+	mua := &mockUnitAsset{
+		Name:        "testUnitAsset",
+		Details:     map[string][]string{"Test": {"Test"}},
+		ServicesMap: *ServicesMap,
+		CervicesMap: *CervicesMap,
+	}
+
+	sys.UAssets = make(map[string]*components.UnitAsset)
+	var muaInterface components.UnitAsset = mua
+	sys.UAssets[mua.GetName()] = &muaInterface
+
+	leadingRegistrar := &components.CoreSystem{
+		Name: "serviceregistrar",
+		Url:  "https://leadingregistrar",
+	}
+	test := &components.CoreSystem{
+		Name: "test",
+		Url:  "https://test",
+	}
+	if broken == false {
+		orchestrator := &components.CoreSystem{
+			Name: "orchestrator",
+			Url:  "https://orchestator",
+		}
+		sys.CoreS = []*components.CoreSystem{
+			leadingRegistrar,
+			orchestrator,
+			test,
+		}
+	} else {
+		orchestrator := &components.CoreSystem{
+			Name: "orchestrator",
+			Url:  brokenUrl,
+		}
+		sys.CoreS = []*components.CoreSystem{
+			leadingRegistrar,
+			orchestrator,
+			test,
+		}
+	}
+	return sys
+}

From 0fd194f5398e7958d89f33e87021d250a9bded51 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 16 Jun 2025 14:23:38 +0200
Subject: [PATCH 044/186] Added the test help functions in utils_test.go and
 changed the test code to work with them

---
 usecases/registration_test.go | 188 ++++------------------------------
 usecases/utils_test.go        | 164 +++++++++++++++++++++++++++++
 2 files changed, 185 insertions(+), 167 deletions(-)
 create mode 100644 usecases/utils_test.go

diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index c293998..84c0160 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -3,7 +3,6 @@ package usecases
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -16,163 +15,18 @@ import (
 	"github.com/sdoque/mbaigo/forms"
 )
 
-type mockTransport struct {
-	returnError bool
-	respFunc    func() *http.Response
-	hits        int
-	err         error
-}
-
-func newMockTransport(respFunc func() *http.Response, v int, err error) mockTransport {
-	t := mockTransport{
-		hits:     v,
-		respFunc: respFunc,
-		err:      err,
-	}
-	http.DefaultClient.Transport = t
-	return t
-}
-
-func (t mockTransport) RoundTrip(req *http.Request) (*http.Response, error) {
-	t.hits -= 1
-	if t.hits == 0 {
-		return nil, t.err
-	}
-	resp := t.respFunc()
-	resp.Request = req
-	return resp, nil
-}
-
 type timeoutError struct{}
 
-type errorReadCloser struct{}
-
-func (e *errorReadCloser) Read(p []byte) (int, error) {
-	return 0, io.EOF
-}
-
-func (e *errorReadCloser) Close() error {
-	return errors.New("Forced close error")
-}
-
 func (timeoutError) Error() string   { return "timeout" }
 func (timeoutError) Timeout() bool   { return true }
 func (timeoutError) Temporary() bool { return true }
 
-var errHTTP error = fmt.Errorf("bad http request")
-
-var brokenUrl = string([]byte{0x7f})
-
-type UnitAsset struct {
-	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
-	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
-	Details     map[string][]string `json:"details"` // Metadata or details about this UA
-	ServicesMap components.Services `json:"-"`
-	CervicesMap components.Cervices `json:"-"`
-	//
-	test int `json:"-"`
-}
-
-type ServiceRecord_v1 struct {
-	Id                int                 `json:"registryID"`
-	ServiceDefinition string              `json:"definition"`
-	SystemName        string              `json:"systemName"`
-	ServiceNode       string              `json:"serviceNode"`
-	IPAddresses       []string            `json:"ipAddresses"`
-	ProtoPort         map[string]int      `json:"protoPort"`
-	Details           map[string][]string `json:"details"`
-	Certificate       string              `json:"certificate"`
-	SubPath           string              `json:"subpath"`
-	RegLife           int                 `json:"registrationLife"`
-	Version           string              `json:"version"`
-	Created           string              `json:"created"`
-	Updated           string              `json:"updated"`
-	EndOfValidity     string              `json:"endOfValidity"`
-	SubscribeAble     bool                `json:"subscribeAble"`
-	ACost             float64             `json:"activityCost"`
-	CUnit             string              `json:"costUnit"`
-}
-
-func (mua *UnitAsset) GetName() string {
-	return mua.Name
-}
-
-func (mua *UnitAsset) GetServices() components.Services {
-	return mua.ServicesMap
-}
-
-func (mua *UnitAsset) GetCervices() components.Cervices {
-	return mua.CervicesMap
-}
-
-func (mua *UnitAsset) GetDetails() map[string][]string {
-	return mua.Details
-}
-
-func (mua *UnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
-	return
-}
-
 type errorReader struct{}
 
 func (errorReader) Read(p []byte) (int, error) {
 	return 0, fmt.Errorf("forced read error")
 }
 
-func createTestSystem(ctx context.Context) components.System {
-	sys := components.NewSystem("testSystem", ctx)
-
-	sys.Husk = &components.Husk{
-		Description: "A test system",
-		Details:     map[string][]string{"Developer": {"Test dev"}},
-		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
-		InfoLink:    "https://for.testing.purposes",
-	}
-
-	orchestrator := &components.CoreSystem{
-		Name: "orchestrator",
-		Url:  "https://orchestrator",
-	}
-	leadingRegistrar := &components.CoreSystem{
-		Name: "serviceregistrar",
-		Url:  "https://leadingregistrar",
-	}
-	test := &components.CoreSystem{
-		Name: "test",
-		Url:  "https://test",
-	}
-	sys.CoreS = []*components.CoreSystem{
-		orchestrator,
-		leadingRegistrar,
-		test,
-	}
-
-	setTest := &components.Service{
-		ID:            1,
-		Definition:    "test",
-		SubPath:       "test",
-		Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
-		Description:   "A test service",
-		RegPeriod:     45,
-		RegTimestamp:  "now",
-		RegExpiration: "45",
-	}
-	ServicesMap := &components.Services{
-		setTest.SubPath: setTest,
-	}
-	mua := &UnitAsset{
-		Name:        "mockUnitAsset",
-		Details:     map[string][]string{"Test": {"Test"}},
-		ServicesMap: *ServicesMap,
-	}
-
-	sys.UAssets = make(map[string]*components.UnitAsset)
-	var muaInterface components.UnitAsset = mua
-	sys.UAssets[mua.GetName()] = &muaInterface
-
-	return sys
-}
-
 type confirmLeadingRegistrarParams struct {
 	testCase         string
 	mockTransportErr int
@@ -231,10 +85,10 @@ func createTestBody(testCase string) (respFunc func() *http.Response) {
 func TestForconfirmLeadingRegistrar(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	testSys := createTestSystem(ctx)
+	testSys := createTestSystem(ctx, false)
 
 	testParams := []confirmLeadingRegistrarParams{
-		{"No errors", 0, nil, testSys.CoreS[1]},
+		{"No errors", 0, nil, testSys.CoreS[0]},
 		{"Read error", 0, nil, nil},
 		{"Prefix error", 0, nil, nil},
 		{"Broken URL", 0, nil, nil},
@@ -247,11 +101,11 @@ func TestForconfirmLeadingRegistrar(t *testing.T) {
 		}
 		newMockTransport(respFunc, test.mockTransportErr, test.errHTTP)
 		if test.testCase == "Broken URL" {
-			testSys.CoreS[1].Url = brokenUrl
+			testSys.CoreS[0].Url = brokenUrl
 		}
 
 		// Do the test
-		res := confirmLeadingRegistrar(testSys.CoreS[1])
+		res := confirmLeadingRegistrar(testSys.CoreS[0])
 		if test.testCase == "No errors" {
 			if res != test.expectedOutput {
 				t.Errorf("Test case: %s got error: %v", test.testCase, res)
@@ -274,10 +128,10 @@ type findLeadingRegistrarParams struct {
 func TestForfindLeadingRegistrar(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	testSys := createTestSystem(ctx)
+	testSys := createTestSystem(ctx, false)
 
 	testParams := []findLeadingRegistrarParams{
-		{"No errors", 0, nil, testSys.CoreS[1]},
+		{"No errors", 0, nil, testSys.CoreS[0]},
 		{"Read error", 0, nil, nil},
 		{"Prefix error", 0, nil, nil},
 		{"Broken URL", 0, nil, nil},
@@ -290,7 +144,7 @@ func TestForfindLeadingRegistrar(t *testing.T) {
 		}
 		newMockTransport(respFunc, test.mockTransportErr, test.errHTTP)
 		if test.testCase == "Broken URL" {
-			testSys.CoreS[1].Url = brokenUrl
+			testSys.CoreS[0].Url = brokenUrl
 		}
 
 		// Do the test
@@ -310,8 +164,8 @@ func TestForfindLeadingRegistrar(t *testing.T) {
 func TestFordeepCopyMap(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	testSys := createTestSystem(ctx)
-	mua := testSys.UAssets["mockUnitAsset"]
+	testSys := createTestSystem(ctx, false)
+	mua := testSys.UAssets["testUnitAsset"]
 	original := (*mua).GetDetails()
 
 	// -- -- -- -- -- -- -- -- -- -- //
@@ -351,9 +205,9 @@ func TestFordeepCopyMap(t *testing.T) {
 func TestForserviceRegistrationForm(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	testSys := createTestSystem(ctx)
-	mua := testSys.UAssets["mockUnitAsset"]
-	serv := (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"]
+	testSys := createTestSystem(ctx, false)
+	mua := testSys.UAssets["testUnitAsset"]
+	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
 	version := "ServiceRecord_v1"
 
 	// -- -- -- -- -- -- -- -- -- -- //
@@ -379,7 +233,7 @@ func TestForserviceRegistrationForm(t *testing.T) {
 	// Check that the ServiceNode is created correctly
 	// -- -- -- -- -- -- -- -- -- -- //
 
-	expectedNode := testSys.Host.Name + "_" + testSys.Name + "_" + (*testSys.UAssets["mockUnitAsset"]).GetName() + "_" + (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"].Definition
+	expectedNode := testSys.Host.Name + "_" + testSys.Name + "_" + (*testSys.UAssets["testUnitAsset"]).GetName() + "_" + (*testSys.UAssets["testUnitAsset"]).GetServices()["test"].Definition
 	if sr.ServiceNode != expectedNode {
 		t.Errorf("Expected ServiceNode %q, got: %q", expectedNode, sr.ServiceNode)
 	}
@@ -425,7 +279,7 @@ func TestForserviceRegistrationForm(t *testing.T) {
 	// Check that when the Service RegPeriod equals 0, ServiceRegistrationForm defaults to its RegLife default value of 30
 	// -- -- -- -- -- -- -- -- -- -- //
 
-	(*testSys.UAssets["mockUnitAsset"]).GetServices()["test"].RegPeriod = 0
+	(*testSys.UAssets["testUnitAsset"]).GetServices()["test"].RegPeriod = 0
 	version = "ServiceRecord_v1"
 	payload, err = serviceRegistrationForm(&testSys, mua, serv, version)
 	if err != nil {
@@ -443,10 +297,10 @@ func TestForserviceRegistrationForm(t *testing.T) {
 func TestForderegisterService(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	testSys := createTestSystem(ctx)
+	testSys := createTestSystem(ctx, false)
 
 	var registrar *components.CoreSystem
-	serv := (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"]
+	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
 
 	respFunc := func() *http.Response {
 		return &http.Response{
@@ -471,7 +325,7 @@ func TestForderegisterService(t *testing.T) {
 	// Good case: No errors when a service registered tries to get deregistered
 	// -- -- -- -- -- -- -- -- -- -- //
 
-	registrar = testSys.CoreS[1]
+	registrar = testSys.CoreS[0]
 
 	err = deregisterService(registrar, serv)
 	if err != nil {
@@ -518,10 +372,10 @@ func TestServiceRegistrationFormList(t *testing.T) {
 func TestForregisterService(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	testSys := createTestSystem(ctx)
-	mua := testSys.UAssets["mockUnitAsset"]
-	serv := (*testSys.UAssets["mockUnitAsset"]).GetServices()["test"]
-	registrar := testSys.CoreS[1]
+	testSys := createTestSystem(ctx, false)
+	mua := testSys.UAssets["testUnitAsset"]
+	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
+	registrar := testSys.CoreS[0]
 
 	payload, err := serviceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
 
diff --git a/usecases/utils_test.go b/usecases/utils_test.go
new file mode 100644
index 0000000..69409b8
--- /dev/null
+++ b/usecases/utils_test.go
@@ -0,0 +1,164 @@
+package usecases
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/sdoque/mbaigo/components"
+)
+
+// mockTransport is used for replacing the default network Transport (used by
+// http.DefaultClient) and it will intercept network requests.
+type mockTransport struct {
+	respFunc func() *http.Response
+	hits     int
+	err      error
+}
+
+func newMockTransport(respFunc func() *http.Response, v int, err error) mockTransport {
+	t := mockTransport{
+		respFunc: respFunc,
+		hits:     v,
+		err:      err,
+	}
+	// Hijack the default http client so no actual http requests are sent over the network
+	http.DefaultClient.Transport = t
+	return t
+}
+
+// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
+// It prevents the request from being sent over the network, and count how many times
+// a http request was sent
+func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	t.hits -= 1
+	//log.Printf("hits: %d", t.hits)
+	if t.hits == 0 {
+		return nil, t.err
+	}
+	resp = t.respFunc()
+	resp.Request = req
+	return resp, nil
+}
+
+// A mocked UnitAsset used for testing
+type mockUnitAsset struct {
+	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
+	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
+	Details     map[string][]string `json:"details"` // Metadata or details about this UA
+	ServicesMap components.Services `json:"-"`
+	CervicesMap components.Cervices `json:"-"`
+}
+
+func (mua mockUnitAsset) GetName() string {
+	return mua.Name
+}
+
+func (mua mockUnitAsset) GetServices() components.Services {
+	return mua.ServicesMap
+}
+
+func (mua mockUnitAsset) GetCervices() components.Cervices {
+	return mua.CervicesMap
+}
+
+func (mua mockUnitAsset) GetDetails() map[string][]string {
+	return mua.Details
+}
+
+func (mua mockUnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {}
+
+// Create a error reader to break json.Unmarshal()
+type errReader int
+
+var errBodyRead error = fmt.Errorf("bad body read")
+
+func (errReader) Read(p []byte) (n int, err error) {
+	return 0, errBodyRead
+}
+func (errReader) Close() error {
+	return nil
+}
+
+// Variables used in testing
+var brokenUrl = string([]byte{0x7f})
+var errHTTP error = fmt.Errorf("bad http request")
+
+// Help function to create a test system
+func createTestSystem(ctx context.Context, broken bool) components.System {
+	// instantiate the System
+	sys := components.NewSystem("testSystem", ctx)
+
+	// Instantiate the Capsule
+	sys.Husk = &components.Husk{
+		Description: "A test system",
+		Details:     map[string][]string{"Developer": {"Test dev"}},
+		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
+		InfoLink:    "https://for.testing.purposes",
+	}
+
+	// create fake services and cervices for a mocked unit asset
+	testCerv := &components.Cervice{
+		Definition: "testCerv",
+		Details:    map[string][]string{"Forms": {"SignalA_v1a"}},
+		Nodes:      map[string][]string{},
+	}
+
+	CervicesMap := &components.Cervices{
+		testCerv.Definition: testCerv,
+	}
+	setTest := &components.Service{
+		ID:            1,
+		Definition:    "test",
+		SubPath:       "test",
+		Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+		Description:   "A test service",
+		RegPeriod:     45,
+		RegTimestamp:  "now",
+		RegExpiration: "45",
+	}
+	ServicesMap := &components.Services{
+		setTest.SubPath: setTest,
+	}
+	mua := &mockUnitAsset{
+		Name:        "testUnitAsset",
+		Details:     map[string][]string{"Test": {"Test"}},
+		ServicesMap: *ServicesMap,
+		CervicesMap: *CervicesMap,
+	}
+
+	sys.UAssets = make(map[string]*components.UnitAsset)
+	var muaInterface components.UnitAsset = mua
+	sys.UAssets[mua.GetName()] = &muaInterface
+
+	leadingRegistrar := &components.CoreSystem{
+		Name: "serviceregistrar",
+		Url:  "https://leadingregistrar",
+	}
+	test := &components.CoreSystem{
+		Name: "test",
+		Url:  "https://test",
+	}
+	if broken == false {
+		orchestrator := &components.CoreSystem{
+			Name: "orchestrator",
+			Url:  "https://orchestator",
+		}
+		sys.CoreS = []*components.CoreSystem{
+			leadingRegistrar,
+			orchestrator,
+			test,
+		}
+	} else {
+		orchestrator := &components.CoreSystem{
+			Name: "orchestrator",
+			Url:  brokenUrl,
+		}
+		sys.CoreS = []*components.CoreSystem{
+			leadingRegistrar,
+			orchestrator,
+			test,
+		}
+	}
+	return sys
+}

From bd95772f49f4ab5159eab71ca8fdccb2cddc9b7c Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 16 Jun 2025 15:53:07 +0200
Subject: [PATCH 045/186] Fixed broken tests

---
 usecases/serviceDiscovery_test.go | 245 +++++++++++-------------------
 usecases/utils_test.go            |   9 +-
 2 files changed, 92 insertions(+), 162 deletions(-)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 64d1984..6fa2819 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -10,46 +10,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
 )
 
-// mockTransport is used for replacing the default network Transport (used by
-// http.DefaultClient) and it will intercept network requests.
-type mockTransport struct {
-	resp *http.Response
-	hits int
-	err  error
-}
-
-func newMockTransport(resp *http.Response, v int, err error) *mockTransport {
-	t := &mockTransport{
-		resp: resp,
-		hits: v,
-		err:  err,
-	}
-	// Hijack the default http client so no actual http requests are sent over the network
-	http.DefaultClient.Transport = t
-	return t
-}
-
-// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
-// It prevents the request from being sent over the network, and count how many times
-// a http request was sent
-func (t *mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-	t.hits -= 1
-	//log.Printf("hits: %d", t.hits)
-	if t.hits == 0 {
-		return nil, t.err
-	}
-	t.resp.Request = req
-	return t.resp, nil
-}
-
-var errHTTP error = fmt.Errorf("bad http request")
-
 // Tests the output from ServQuestForms() to ensure expected outcome
-
 func TestServQuestForms(t *testing.T) {
 	expectedForms := []string{"ServiceQuest_v1", "ServicePoint_v1"}
 	lst := ServQuestForms()
@@ -61,89 +25,11 @@ func TestServQuestForms(t *testing.T) {
 	}
 }
 
-type UnitAsset struct {
-	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
-	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
-	Details     map[string][]string `json:"details"` // Metadata or details about this UA
-	ServicesMap components.Services `json:"-"`
-	CervicesMap components.Cervices `json:"-"`
-}
-
-func (mua UnitAsset) GetName() string {
-	return mua.Name
-}
-
-func (mua UnitAsset) GetServices() components.Services {
-	return mua.ServicesMap
-}
-
-func (mua UnitAsset) GetCervices() components.Cervices {
-	return mua.CervicesMap
-}
-
-func (mua UnitAsset) GetDetails() map[string][]string {
-	return mua.Details
-}
-
-func (mua UnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {}
-
-func createTestSystem(ctx context.Context, broken bool) components.System {
-	// instantiate the System
-	sys := components.NewSystem("testSystem", ctx)
-
-	// Instantiate the Capsule
-	sys.Husk = &components.Husk{
-		Description: "A test system",
-		Details:     map[string][]string{"Developer": {"Test dev"}},
-		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
-		InfoLink:    "https://for.testing.purposes",
-	}
-
-	testCerv := &components.Cervice{
-		Definition: "testCerv",
-		Details:    map[string][]string{"Forms": {"SignalA_v1a"}},
-		Nodes:      map[string][]string{},
-	}
-
-	CervicesMap := &components.Cervices{
-		testCerv.Definition: testCerv,
-	}
-
-	mua := &UnitAsset{
-		Name:        "testUnitAsset",
-		Details:     map[string][]string{"Test": {"Test"}},
-		CervicesMap: *CervicesMap,
-	}
-
-	sys.UAssets = make(map[string]*components.UnitAsset)
-	var muaInterface components.UnitAsset = mua
-	sys.UAssets[mua.GetName()] = &muaInterface
-
-	if broken == false {
-		orchestrator := &components.CoreSystem{
-			Name: "orchestrator",
-			Url:  "https://orchestator",
-		}
-		sys.CoreS = []*components.CoreSystem{
-			orchestrator,
-		}
-	} else {
-		orchestrator := &components.CoreSystem{
-			Name: "orchestrator",
-			Url:  brokenUrl,
-		}
-		sys.CoreS = []*components.CoreSystem{
-			orchestrator,
-		}
-	}
-	return sys
-}
-
 func TestFillQuestForm(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	testSys := createTestSystem(ctx, false)
-	mua := UnitAsset{}
+	mua := mockUnitAsset{}
 	questForm := FillQuestForm(&testSys, mua, "TestDef", "TestProtocol")
 	// Loop through the details in questForm and mua (mockUnitAsset), error if they're not the same
 	for i, detail := range questForm.Details["Details"] {
@@ -256,20 +142,6 @@ func createServicePointTestForm() forms.ServicePoint_v1 {
 	return f
 }
 
-// Create a error reader to break json.unmarshal
-type errReader int
-
-var errBodyRead error = fmt.Errorf("bad body read")
-
-func (errReader) Read(p []byte) (n int, err error) {
-	return 0, errBodyRead
-}
-func (errReader) Close() error {
-	return nil
-}
-
-var brokenUrl = string([]byte{0x7f})
-
 type SendHttpReqParams struct {
 	testCase    string
 	method      string
@@ -280,14 +152,17 @@ type SendHttpReqParams struct {
 	expectError bool
 }
 
-func testSystemSetup() (resp *http.Response, data []byte, ctx context.Context, cancel context.CancelFunc, err error) {
+func testSystemSetup() (resp func() *http.Response, data []byte, ctx context.Context, cancel context.CancelFunc, err error) {
 	ctx, cancel = context.WithCancel(context.Background())
 	var form forms.ServiceQuest_v1
 	form.NewForm()
-	resp = &http.Response{
-		Status:     "200 OK",
-		StatusCode: 200,
-		Body:       io.NopCloser(strings.NewReader(string("test body"))),
+	resp = func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("test body"))),
+		}
 	}
 	data, err = json.MarshalIndent(form, "", "  ")
 	if err != nil {
@@ -344,10 +219,13 @@ func TestSearch4Service(t *testing.T) {
 	if err != nil {
 		t.Errorf("Fail Marshal at start of test")
 	}
-	resp := &http.Response{
-		Status:     "200 OK",
-		StatusCode: 200,
-		Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+	resp := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+		}
 	}
 	newMockTransport(resp, 0, nil)
 	ctx, cancel := context.WithCancel(context.Background())
@@ -378,6 +256,14 @@ func TestSearch4Service(t *testing.T) {
 	cancel()
 
 	// Error at sendHttpRequest
+	resp = func() *http.Response {
+		return &http.Response{
+			Status:     "200 ?",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+		}
+	}
 	newMockTransport(resp, 2, errHTTP)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
@@ -389,7 +275,14 @@ func TestSearch4Service(t *testing.T) {
 	cancel()
 
 	// Non-2xx status code of response from sendHttpRequest()
-	resp.StatusCode = 300
+	resp = func() *http.Response {
+		return &http.Response{
+			Status:     "300 ?",
+			StatusCode: 300,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+		}
+	}
 	newMockTransport(resp, 0, nil)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
@@ -401,9 +294,16 @@ func TestSearch4Service(t *testing.T) {
 	cancel()
 
 	// Error at "Read the response", io.ReadAll()
-	resp.StatusCode = 200
+	resp = func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       errReader(0),
+		}
+	}
 	f = createServicePointTestForm()
-	resp.Body = errReader(0)
+	//resp.Body = errReader(0)
 	newMockTransport(resp, 0, nil)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
@@ -416,7 +316,15 @@ func TestSearch4Service(t *testing.T) {
 
 	// Error at "Read the response", ExtractDiscoveryForm()
 	f = createServicePointTestForm()
-	resp.Body = io.NopCloser(strings.NewReader(string("test")))
+	resp = func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("test"))),
+		}
+	}
+	//resp.Body = io.NopCloser(strings.NewReader(string("test")))
 	newMockTransport(resp, 0, nil)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
@@ -459,13 +367,14 @@ func TestSearch4Services(t *testing.T) {
 	if err != nil {
 		t.Error("Error in test during json.Marshal()")
 	}
-	resp := &http.Response{
-		Status:     "200 OK",
-		StatusCode: 200,
-		Body:       io.NopCloser(strings.NewReader(string(data))),
+	resp := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(data))),
+		}
 	}
-	resp.Header = make(http.Header)
-	resp.Header.Set("Content-Type", "application/json")
 	newMockTransport(resp, 0, nil)
 	ctx, cancel := context.WithCancel(context.Background())
 	testSys := createTestSystem(ctx, false)
@@ -490,7 +399,11 @@ func TestSearch4Services(t *testing.T) {
 	newMockTransport(resp, 0, nil)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
-	(*testSys.CoreS[0]).Url = ""
+	for i, cs := range testSys.CoreS {
+		if cs.Name == "orchestrator" {
+			(*testSys.CoreS[i]).Url = ""
+		}
+	}
 	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 	err = Search4Services(cer, &testSys)
 	if err == nil {
@@ -499,8 +412,6 @@ func TestSearch4Services(t *testing.T) {
 	cancel()
 
 	// Bad case: sendHttpReq() returns an error
-	// TODO: Fix this, maybe change the mockTransport to count number of times it's been called
-	// and then change the retError to true and it should fail.
 	newMockTransport(resp, 2, nil)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
@@ -512,7 +423,14 @@ func TestSearch4Services(t *testing.T) {
 	cancel()
 
 	// Bad case: Response status code is < 200 or >= 300
-	resp.StatusCode = 199
+	resp = func() *http.Response {
+		return &http.Response{
+			Status:     "199 ?",
+			StatusCode: 199,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(data))),
+		}
+	}
 	newMockTransport(resp, 4, errHTTP)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
@@ -524,8 +442,14 @@ func TestSearch4Services(t *testing.T) {
 	cancel()
 
 	// Bad case: io.ReadAll() return an error
-	resp.StatusCode = 200
-	resp.Body = errReader(0)
+	resp = func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       errReader(0),
+		}
+	}
 	newMockTransport(resp, 0, nil)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
@@ -536,9 +460,15 @@ func TestSearch4Services(t *testing.T) {
 	}
 	cancel()
 
-	// Bad case: Unpack() returns an error
-	resp.Body = io.NopCloser(strings.NewReader(string(data)))
-	resp.Header.Set("Content-Type", "Error")
+	// Bad case: Unpack() returns an error and type assertion/conversion fails
+	resp = func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"Error"}},
+			Body:       io.NopCloser(strings.NewReader(string(data))),
+		}
+	}
 	newMockTransport(resp, 0, nil)
 	ctx, cancel = context.WithCancel(context.Background())
 	testSys = createTestSystem(ctx, false)
@@ -548,6 +478,7 @@ func TestSearch4Services(t *testing.T) {
 		t.Errorf("Expected errors")
 	}
 	cancel()
+
 }
 
 func createTestServiceRecord(number int) (f forms.ServiceRecord_v1) {
diff --git a/usecases/utils_test.go b/usecases/utils_test.go
index 69409b8..9defc85 100644
--- a/usecases/utils_test.go
+++ b/usecases/utils_test.go
@@ -16,8 +16,8 @@ type mockTransport struct {
 	err      error
 }
 
-func newMockTransport(respFunc func() *http.Response, v int, err error) mockTransport {
-	t := mockTransport{
+func newMockTransport(respFunc func() *http.Response, v int, err error) *mockTransport {
+	t := &mockTransport{
 		respFunc: respFunc,
 		hits:     v,
 		err:      err,
@@ -30,11 +30,10 @@ func newMockTransport(respFunc func() *http.Response, v int, err error) mockTran
 // RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
 // It prevents the request from being sent over the network, and count how many times
 // a http request was sent
-func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+func (t *mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
 	t.hits -= 1
-	//log.Printf("hits: %d", t.hits)
 	if t.hits == 0 {
-		return nil, t.err
+		return resp, t.err
 	}
 	resp = t.respFunc()
 	resp.Request = req

From 350ccab93602310af060e524ed05f6d8e60b0099 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 16 Jun 2025 16:50:04 +0200
Subject: [PATCH 046/186] Fixed the stuff commented on in the review of the
 pull request

---
 usecases/registration.go      |  34 +++-------
 usecases/registration_test.go | 118 +++++++++++++---------------------
 usecases/utils_test.go        |  10 +--
 3 files changed, 60 insertions(+), 102 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index ba755b0..774ec05 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -23,7 +23,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"io"
 	"log"
 	"net"
@@ -79,7 +78,7 @@ func RegisterServices(sys *components.System) {
 					case <-sys.Ctx.Done():
 						err := deregisterService(leadingRegistrar, theService)
 						if err != nil {
-							fmt.Println("deregistering service:", err)
+							log.Println("deregistering service:", err)
 						}
 						return
 					}
@@ -93,23 +92,18 @@ func confirmLeadingRegistrar(leadingRegistrar *components.CoreSystem) *component
 	resp, err := http.Get(leadingRegistrar.Url + "/status")
 	if err != nil {
 		log.Println("lost leading registrar status:", err)
-		leadingRegistrar = nil
-		return leadingRegistrar
+		return nil
 	}
 	// Read from resp.Body and then close it directly after
 	bodyBytes, err := io.ReadAll(resp.Body)
-	errClose := resp.Body.Close() // Close the body directly after reading from it
+	defer resp.Body.Close() // Close the body directly after reading from it
 	if err != nil {
 		log.Println("\rError reading response from leading registrar:", err)
-		leadingRegistrar = nil
-		return leadingRegistrar
-	}
-	if errClose != nil {
-		log.Println("Error closing the leading registrar response body:", errClose)
+		return nil
 	}
 	if !strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
-		leadingRegistrar = nil
 		log.Println("lost previous leading registrar")
+		return nil
 	}
 	return leadingRegistrar
 }
@@ -122,22 +116,19 @@ func findLeadingRegistrar(sys *components.System, leadingRegistrar *components.C
 
 		resp, err := http.Get(core.Url + "/status")
 		if err != nil {
-			fmt.Println("error checking service registrar status:", err)
+			log.Println("error checking service registrar status:", err)
 			continue // Skip to the next iteration of the loop
 		}
 
 		// Read from resp.Body and then close it directly after
 		bodyBytes, err := io.ReadAll(resp.Body)
-		errClose := resp.Body.Close() // Close the body directly after reading from it
+		defer resp.Body.Close() // Close the body directly after reading from it
 		if err != nil {
-			fmt.Println("Error reading service registrar response body:", err)
+			log.Println("Error reading service registrar response body:", err)
 			continue // Skip to the next iteration of the loop
 		}
-		if errClose != nil {
-			fmt.Println("Error closing service registrar response body:", errClose)
-		}
 		if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
-			fmt.Printf("\nlead registrar found at: %s\n", core.Url)
+			log.Printf("lead registrar found at: %s", core.Url)
 			return core
 		}
 	}
@@ -171,7 +162,6 @@ func registerService(sys *components.System, ua *components.UnitAsset, serv *com
 		}
 	}
 	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
-	// client := &http.Client{Timeout: time.Second * 5}
 
 	resp, err := http.DefaultClient.Do(req) // execute the request and get the reply
 	if err != nil {
@@ -209,7 +199,7 @@ func registerService(sys *components.System, ua *components.UnitAsset, serv *com
 		// Perform a type assertion to convert the returned Form to ServiceRecord_v1
 		rr, ok := rRecord.(*forms.ServiceRecord_v1)
 		if !ok {
-			fmt.Println("Problem unpacking the service registration reply")
+			log.Println("Problem unpacking the service registration reply")
 			return
 		}
 
@@ -223,7 +213,6 @@ func registerService(sys *components.System, ua *components.UnitAsset, serv *com
 		}
 		delay = time.Until(parsedTime.Add(-5 * time.Second)) // should not wait until the deadline to start to confirrm live status
 	}
-
 	return
 }
 
@@ -233,7 +222,6 @@ func deregisterService(registrar *components.CoreSystem, serv *components.Servic
 		return nil // there is no need to deregister if there is no leading registrar
 	}
 	deRegServURL := registrar.Url + "/unregister/" + strconv.Itoa(serv.ID)
-	// fmt.Printf("Trying to unregister %s\n", deRegServURL)
 	req, err := http.NewRequest("DELETE", deRegServURL, nil) // create a new request using http
 	if err != nil {
 		return err
@@ -243,7 +231,6 @@ func deregisterService(registrar *components.CoreSystem, serv *components.Servic
 		return err
 	}
 	defer resp.Body.Close()
-	// fmt.Printf("service %s deleted from the service registrar with HTTP Response Status: %d, %s\n", serv.Definition, resp.StatusCode, http.StatusText(resp.StatusCode))
 	return nil
 }
 
@@ -299,7 +286,6 @@ func deepCopyMap(m map[string][]string) map[string][]string {
 	return newMap
 }
 
-// TODO: Research if this function is even needed
 // ServiceRegistrationFormsList returns the list of forms that the service registration handles
 func ServiceRegistrationFormsList() []string {
 	return []string{"ServiceRecord_v1"}
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 84c0160..926c75f 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -1,7 +1,6 @@
 package usecases
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -27,79 +26,78 @@ func (errorReader) Read(p []byte) (int, error) {
 	return 0, fmt.Errorf("forced read error")
 }
 
-type confirmLeadingRegistrarParams struct {
+type tableDrivenParams struct {
 	testCase         string
+	body             func() *http.Response
 	mockTransportErr int
 	errHTTP          error
 	expectedOutput   *components.CoreSystem
 }
 
-func createTestBody(testCase string) (respFunc func() *http.Response) {
-	if testCase == "No errors" {
-		respFunc := func() *http.Response {
+var testParams = []tableDrivenParams{
+	{
+		"No errors",
+		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
 				StatusCode: 200,
 				Header:     http.Header{"Content-Type": []string{"application/json"}},
 				Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
 			}
-		}
-		return respFunc
-	}
-	if testCase == "Read error" {
-		respFunc := func() *http.Response {
+		},
+		0,
+		nil,
+		nil,
+	},
+	{
+		"Read error",
+		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
 				StatusCode: 200,
 				Header:     http.Header{"Content-Type": []string{"application/json"}},
 				Body:       io.NopCloser(errorReader{}),
 			}
-		}
-		return respFunc
-	}
-	if testCase == "Prefix error" {
-		respFunc := func() *http.Response {
+		},
+		0,
+		nil,
+		nil,
+	},
+	{
+		"Prefix error",
+		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
 				StatusCode: 200,
 				Header:     http.Header{"Content-Type": []string{"application/json"}},
 				Body:       io.NopCloser(strings.NewReader(string("Wrong prefix"))),
 			}
-		}
-		return respFunc
-	}
-	if testCase == "Broken URL" {
-		respFunc := func() *http.Response {
+		},
+		0,
+		nil,
+		nil,
+	},
+	{
+		"Broken URL",
+		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
 				StatusCode: 200,
 				Header:     http.Header{"Content-Type": []string{"application/json"}},
 				Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
 			}
-		}
-		return respFunc
-	}
-	return nil
+		},
+		0,
+		nil,
+		nil,
+	},
 }
 
 func TestForconfirmLeadingRegistrar(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx, false)
-
-	testParams := []confirmLeadingRegistrarParams{
-		{"No errors", 0, nil, testSys.CoreS[0]},
-		{"Read error", 0, nil, nil},
-		{"Prefix error", 0, nil, nil},
-		{"Broken URL", 0, nil, nil},
-	}
+	testSys := createTestSystem(false)
 
 	for _, test := range testParams {
-		respFunc := createTestBody(test.testCase)
-		if respFunc == nil {
-			t.Errorf("---\tError occurred while creating test data")
-		}
-		newMockTransport(respFunc, test.mockTransportErr, test.errHTTP)
+		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
 		if test.testCase == "Broken URL" {
 			testSys.CoreS[0].Url = brokenUrl
 		}
@@ -107,6 +105,7 @@ func TestForconfirmLeadingRegistrar(t *testing.T) {
 		// Do the test
 		res := confirmLeadingRegistrar(testSys.CoreS[0])
 		if test.testCase == "No errors" {
+			test.expectedOutput = testSys.CoreS[0]
 			if res != test.expectedOutput {
 				t.Errorf("Test case: %s got error: %v", test.testCase, res)
 			}
@@ -118,31 +117,11 @@ func TestForconfirmLeadingRegistrar(t *testing.T) {
 	}
 }
 
-type findLeadingRegistrarParams struct {
-	testCase         string
-	mockTransportErr int
-	errHTTP          error
-	expectedOutput   *components.CoreSystem
-}
-
 func TestForfindLeadingRegistrar(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx, false)
-
-	testParams := []findLeadingRegistrarParams{
-		{"No errors", 0, nil, testSys.CoreS[0]},
-		{"Read error", 0, nil, nil},
-		{"Prefix error", 0, nil, nil},
-		{"Broken URL", 0, nil, nil},
-	}
+	testSys := createTestSystem(false)
 
 	for _, test := range testParams {
-		respFunc := createTestBody(test.testCase)
-		if respFunc == nil {
-			t.Errorf("---\tError occurred while creating test data")
-		}
-		newMockTransport(respFunc, test.mockTransportErr, test.errHTTP)
+		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
 		if test.testCase == "Broken URL" {
 			testSys.CoreS[0].Url = brokenUrl
 		}
@@ -150,6 +129,7 @@ func TestForfindLeadingRegistrar(t *testing.T) {
 		// Do the test
 		res := findLeadingRegistrar(&testSys, nil)
 		if test.testCase == "No errors" {
+			test.expectedOutput = testSys.CoreS[0]
 			if res != test.expectedOutput {
 				t.Errorf("Test case: %s got error: %v", test.testCase, res)
 			}
@@ -162,9 +142,7 @@ func TestForfindLeadingRegistrar(t *testing.T) {
 }
 
 func TestFordeepCopyMap(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx, false)
+	testSys := createTestSystem(false)
 	mua := testSys.UAssets["testUnitAsset"]
 	original := (*mua).GetDetails()
 
@@ -203,9 +181,7 @@ func TestFordeepCopyMap(t *testing.T) {
 }
 
 func TestForserviceRegistrationForm(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx, false)
+	testSys := createTestSystem(false)
 	mua := testSys.UAssets["testUnitAsset"]
 	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
 	version := "ServiceRecord_v1"
@@ -295,9 +271,7 @@ func TestForserviceRegistrationForm(t *testing.T) {
 }
 
 func TestForderegisterService(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx, false)
+	testSys := createTestSystem(false)
 
 	var registrar *components.CoreSystem
 	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
@@ -370,9 +344,7 @@ func TestServiceRegistrationFormList(t *testing.T) {
 }
 
 func TestForregisterService(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx, false)
+	testSys := createTestSystem(false)
 	mua := testSys.UAssets["testUnitAsset"]
 	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
 	registrar := testSys.CoreS[0]
diff --git a/usecases/utils_test.go b/usecases/utils_test.go
index 69409b8..4880c3c 100644
--- a/usecases/utils_test.go
+++ b/usecases/utils_test.go
@@ -16,8 +16,8 @@ type mockTransport struct {
 	err      error
 }
 
-func newMockTransport(respFunc func() *http.Response, v int, err error) mockTransport {
-	t := mockTransport{
+func newMockTransport(respFunc func() *http.Response, v int, err error) *mockTransport {
+	t := &mockTransport{
 		respFunc: respFunc,
 		hits:     v,
 		err:      err,
@@ -30,9 +30,8 @@ func newMockTransport(respFunc func() *http.Response, v int, err error) mockTran
 // RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
 // It prevents the request from being sent over the network, and count how many times
 // a http request was sent
-func (t mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+func (t *mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
 	t.hits -= 1
-	//log.Printf("hits: %d", t.hits)
 	if t.hits == 0 {
 		return nil, t.err
 	}
@@ -85,8 +84,9 @@ var brokenUrl = string([]byte{0x7f})
 var errHTTP error = fmt.Errorf("bad http request")
 
 // Help function to create a test system
-func createTestSystem(ctx context.Context, broken bool) components.System {
+func createTestSystem(broken bool) components.System {
 	// instantiate the System
+	ctx := context.Background()
 	sys := components.NewSystem("testSystem", ctx)
 
 	// Instantiate the Capsule

From 1b90f5dac3638ae26c0380ff5642a0d5ed99f3bc Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 17 Jun 2025 09:43:40 +0200
Subject: [PATCH 047/186] Fixed comments from code review

---
 usecases/serviceDiscovery.go      |  52 ++++-----------
 usecases/serviceDiscovery_test.go | 101 +++++-------------------------
 usecases/utils_test.go            |   7 ++-
 3 files changed, 30 insertions(+), 130 deletions(-)

diff --git a/usecases/serviceDiscovery.go b/usecases/serviceDiscovery.go
index 3c1cd7a..9c1f01d 100644
--- a/usecases/serviceDiscovery.go
+++ b/usecases/serviceDiscovery.go
@@ -21,14 +21,11 @@ package usecases
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
-	"time"
 
 	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
@@ -45,8 +42,6 @@ func FillQuestForm(sys *components.System, res components.UnitAsset, sDef, proto
 	f.NewForm()
 	f.RequesterName = sys.Name
 	f.ServiceDefinition = sDef
-	// TODO: known bug on commit
-	// f.Protocol = append()
 	f.Protocol = protocol
 	f.Details = res.GetDetails()
 	return f
@@ -62,7 +57,7 @@ func ExtractQuestForm(bodyBytes []byte) (rec forms.ServiceQuest_v1, err error) {
 	}
 	formVersion, ok := jsonData["version"].(string)
 	if !ok {
-		log.Printf("Error: 'version' key not found in JSON data")
+		log.Printf("'version' key not found in JSON data")
 		return
 	}
 
@@ -76,53 +71,45 @@ func ExtractQuestForm(bodyBytes []byte) (rec forms.ServiceQuest_v1, err error) {
 		}
 		rec = f
 	default:
-		err = errors.New("unsupported service registration form version")
+		err = fmt.Errorf("unsupported service registration form version")
 	}
 	return
 }
 
-func sendHttpReq(method string, url string, data []byte, ctx context.Context) (resp *http.Response, err error) {
+func sendHttpReq(method string, url string, data []byte) (resp *http.Response, err error) {
 	req, err := http.NewRequest(method, url, bytes.NewBuffer(data))
 	if err != nil {
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json") // set the Content-Type header
-	req = req.WithContext(ctx)                         // associate the cancellable context with the request
-
 	resp, err = http.DefaultClient.Do(req)
 	if err != nil {
 		return nil, err
 	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return resp, fmt.Errorf("received non-2xx status code: %d, response: %s from the Orchestrator", resp.StatusCode, http.StatusText(resp.StatusCode))
+	}
 	return
 }
 
 // Search4Service requests from the core systems the address of resources's services that meet the need
 func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocation forms.ServicePoint_v1, err error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) // Create a new context, with a 2-second timeout
-	defer cancel()
-
 	// Create a new HTTP request to the Orchestrator system (for now the Service Registrar)
 	orchestratorPointer, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
 	if err != nil {
 		return servLocation, err
 	}
-
 	// prepare the payload to perform a service quest
 	oURL := orchestratorPointer + "/squest"
 	jsonQF, err := json.MarshalIndent(qf, "", "  ")
 	if err != nil {
 		return servLocation, err
 	}
-
-	resp, err := sendHttpReq(http.MethodPost, oURL, jsonQF, ctx)
+	resp, err := sendHttpReq(http.MethodPost, oURL, jsonQF)
 	if err != nil {
 		return servLocation, err
 	}
 	defer resp.Body.Close()
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return servLocation, fmt.Errorf("received non-2xx status code: %d, response: %s from the Orchestrator", resp.StatusCode, http.StatusText(resp.StatusCode))
-	}
-
 	// Read the response /////////////////////////////////
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
@@ -146,58 +133,43 @@ func Search4Services(cer *components.Cervice, sys *components.System) (err error
 		Details:           cer.Details,
 		Version:           "ServiceQuest_v1",
 	}
-
 	//pack the service quest form
 	qf, err := Pack(&questForm, "application/json")
 	if err != nil {
 		return err
 	}
-
 	// Search for an Orchestrator system within the local cloud
 	orchestratorPointer, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
 	if err != nil {
 		return err
 	}
 	if orchestratorPointer == "" {
-		err = errors.New("failed to locate an Orchestrator")
+		err = fmt.Errorf("failed to locate an Orchestrator")
 		return err
 	}
 	oURL := orchestratorPointer + "/squest"
-
 	// Prepare the request to the Orchestrator
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) // Create a new context, with a 2-second timeout
-	defer cancel()
-
-	resp, err := sendHttpReq(http.MethodPost, oURL, qf, ctx)
+	resp, err := sendHttpReq(http.MethodPost, oURL, qf)
 	if err != nil {
 		return
 	}
 	defer resp.Body.Close()
-
-	// Check if the status code indicates an error (anything outside the 200–299 range)
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return fmt.Errorf("received non-2xx status code: %d, response: %s from the Orchestrator", resp.StatusCode, http.StatusText(resp.StatusCode))
-	}
-
 	// Read the response /////////////////////////////////
 	bodyBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return err
 	}
-
 	headerContentTtype := resp.Header.Get("Content-Type")
 	discoveryForm, err := Unpack(bodyBytes, headerContentTtype)
 	if err != nil {
 		log.Printf("error extracting the discovery request %v\n", err)
 	}
-
 	// Perform a type assertion to convert the returned Form to ServicePoint_v1
 	df, ok := discoveryForm.(*forms.ServicePoint_v1)
 	if !ok {
 		fmt.Println("Problem unpacking the service discovery request form")
 		return
 	}
-
 	cer.Nodes[df.ServNode] = append(cer.Nodes[df.ServNode], df.ServLocation)
 	return err
 }
@@ -213,7 +185,7 @@ func FillDiscoveredServices(dsList []forms.ServiceRecord_v1, version string) (f
 			dslForm.List = append(dslForm.List, *sf)
 		}
 	default:
-		err = errors.New("unsupported service registration form version")
+		err = fmt.Errorf("unsupported service registration form version")
 		return
 	}
 	return
@@ -229,7 +201,7 @@ func ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err err
 	}
 	formVersion, ok := jsonData["version"].(string)
 	if !ok {
-		err = errors.New("error: 'version' key not found in JSON data")
+		err = fmt.Errorf("'version' key not found in JSON data")
 		return
 	}
 	switch formVersion {
@@ -243,7 +215,7 @@ func ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err err
 		}
 		sLoc = f
 	default:
-		err = errors.New("unsupported service discovery form version")
+		err = fmt.Errorf("unsupported service discovery form version")
 	}
 	return
 }
diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 6fa2819..889e9b8 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -26,9 +26,7 @@ func TestServQuestForms(t *testing.T) {
 }
 
 func TestFillQuestForm(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	testSys := createTestSystem(ctx, false)
+	testSys, _ := createTestSystem(false)
 	mua := mockUnitAsset{}
 	questForm := FillQuestForm(&testSys, mua, "TestDef", "TestProtocol")
 	// Loop through the details in questForm and mua (mockUnitAsset), error if they're not the same
@@ -86,7 +84,7 @@ func createTestData(bodyType string, proto int, version string, errRead bool) (d
 	}
 }
 
-type ExtractQuestFormParams struct {
+type extractQuestFormParams struct {
 	testCase      string
 	bodyType      string
 	protocol      int
@@ -97,7 +95,7 @@ type ExtractQuestFormParams struct {
 
 func TestExtractQuestForm(t *testing.T) {
 	// A list holding structs containing the parameters used for the test
-	testParams := []ExtractQuestFormParams{
+	testParams := []extractQuestFormParams{
 		// {testCase, bodyType, protocol, version, errRead, expectedError}
 		// Always start with the "Best case, no errors"
 		{"No errors", "testBodyHasVersion", -1, "ServiceQuest_v1", false, false},
@@ -142,7 +140,7 @@ func createServicePointTestForm() forms.ServicePoint_v1 {
 	return f
 }
 
-type SendHttpReqParams struct {
+type sendHttpReqParams struct {
 	testCase    string
 	method      string
 	url         string
@@ -152,8 +150,8 @@ type SendHttpReqParams struct {
 	expectError bool
 }
 
-func testSystemSetup() (resp func() *http.Response, data []byte, ctx context.Context, cancel context.CancelFunc, err error) {
-	ctx, cancel = context.WithCancel(context.Background())
+func testSystemSetup() (resp func() *http.Response, data []byte, ctx context.Context, err error) {
+	ctx = context.Background()
 	var form forms.ServiceQuest_v1
 	form.NewForm()
 	resp = func() *http.Response {
@@ -166,21 +164,19 @@ func testSystemSetup() (resp func() *http.Response, data []byte, ctx context.Con
 	}
 	data, err = json.MarshalIndent(form, "", "  ")
 	if err != nil {
-		return nil, nil, ctx, cancel, errors.New("---\tError occurred while marshalling in test system setup")
+		return nil, nil, ctx, errors.New("---\tError occurred while marshalling in test system setup")
 	}
 	return
 }
 
 func TestSendHttpReq(t *testing.T) {
-	resp, data, ctx, cancel, err := testSystemSetup()
-	defer cancel()
+	resp, data, ctx, err := testSystemSetup()
 	newMockTransport(resp, 0, nil)
 	if err != nil {
 		t.Errorf("Error occurred while starting test system: %e", err)
 	}
-	params := []SendHttpReqParams{
+	params := []sendHttpReqParams{
 		// {testCase, method, url, data, ctx, respError, expectError}
-		// Always start with the "Best case, no errors"
 		{"No errors", http.MethodPost, "http://test", data, ctx, false, false},
 		{"Error creating new request", http.MethodPost, brokenUrl, data, ctx, false, true},
 		{"DefaultClient returns error", http.MethodPost, "http://test", data, ctx, true, true},
@@ -198,7 +194,7 @@ func TestSendHttpReq(t *testing.T) {
 			lastLoopErr = true
 		}
 		// Run the test
-		_, err = sendHttpReq(c.method, c.url, c.data, c.ctx)
+		_, err = sendHttpReq(c.method, c.url, c.data)
 		if c.expectError == false {
 			if err != nil {
 				t.Errorf("Unexpected error in '%s' test case: %e", c.testCase, err)
@@ -228,10 +224,8 @@ func TestSearch4Service(t *testing.T) {
 		}
 	}
 	newMockTransport(resp, 0, nil)
-	ctx, cancel := context.WithCancel(context.Background())
-	testSys := createTestSystem(ctx, false)
+	testSys, _ := createTestSystem(false)
 	var qForm forms.ServiceQuest_v1
-
 	serviceForm, err := Search4Service(qForm, &testSys)
 	if err != nil {
 		t.Errorf("Expected no errors, got: %v", err)
@@ -239,21 +233,17 @@ func TestSearch4Service(t *testing.T) {
 	if serviceForm.ServLocation != f.ServLocation {
 		t.Errorf("Expected %s, got: %s", f.ServLocation, serviceForm.ServLocation)
 	}
-	cancel()
 
 	// Error at "prepare the payload to perform a service quest"
 	// Untested because I found no way of breaking json.Marshal, without making big changes to the form
 
 	// Error while getting core system url
 	newMockTransport(resp, 1, errHTTP)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
 	qForm.NewForm()
 	_, err = Search4Service(qForm, &testSys)
 	if err == nil {
 		t.Errorf("Expected error at GetRunningCoreSystemURL()")
 	}
-	cancel()
 
 	// Error at sendHttpRequest
 	resp = func() *http.Response {
@@ -265,14 +255,11 @@ func TestSearch4Service(t *testing.T) {
 		}
 	}
 	newMockTransport(resp, 2, errHTTP)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
 	qForm.NewForm()
 	_, err = Search4Service(qForm, &testSys)
 	if err == nil {
 		t.Errorf("Expected error at sendHttpRequest()")
 	}
-	cancel()
 
 	// Non-2xx status code of response from sendHttpRequest()
 	resp = func() *http.Response {
@@ -284,14 +271,11 @@ func TestSearch4Service(t *testing.T) {
 		}
 	}
 	newMockTransport(resp, 0, nil)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
 	qForm.NewForm()
 	_, err = Search4Service(qForm, &testSys)
 	if err == nil {
 		t.Errorf("Expected error at sendHttpRequest")
 	}
-	cancel()
 
 	// Error at "Read the response", io.ReadAll()
 	resp = func() *http.Response {
@@ -303,16 +287,12 @@ func TestSearch4Service(t *testing.T) {
 		}
 	}
 	f = createServicePointTestForm()
-	//resp.Body = errReader(0)
 	newMockTransport(resp, 0, nil)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
 	qForm.NewForm()
 	serviceForm, err = Search4Service(qForm, &testSys)
 	if err == nil {
 		t.Errorf("Expected error")
 	}
-	cancel()
 
 	// Error at "Read the response", ExtractDiscoveryForm()
 	f = createServicePointTestForm()
@@ -324,32 +304,15 @@ func TestSearch4Service(t *testing.T) {
 			Body:       io.NopCloser(strings.NewReader(string("test"))),
 		}
 	}
-	//resp.Body = io.NopCloser(strings.NewReader(string("test")))
 	newMockTransport(resp, 0, nil)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
 	qForm.NewForm()
 	serviceForm, err = Search4Service(qForm, &testSys)
 	if err == nil {
 		t.Errorf("Expected error")
 	}
-	cancel()
-
 }
 
-// Search4Services(cer *components.Cervice, sys *components.System) (err error)
-// *forms.ServicePoint_v1
-/*
-   ServiceID         int                 `json:"serviceId"`
-   ProviderName      string              `json:"providerName"`
-   ServiceDefinition string              `json:"definition"`
-   Details           map[string][]string `json:"details"`
-   ServLocation      string              `json:"serviceURL"`
-   ServNode          string              `json:"serviceNode"`
-   Token             string              `json:"token"`
-   Version           string              `json:"version"`
-*/
-
+// Used to create a ServicePoint_v1 form for testing purposes
 func createTestServicePoint() (f forms.ServicePoint_v1) {
 	f.ProviderName = "testProvider"
 	f.ServiceDefinition = "testDef"
@@ -376,29 +339,22 @@ func TestSearch4Services(t *testing.T) {
 		}
 	}
 	newMockTransport(resp, 0, nil)
-	ctx, cancel := context.WithCancel(context.Background())
-	testSys := createTestSystem(ctx, false)
+	testSys, _ := createTestSystem(false)
 	cer := (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 	err = Search4Services(cer, &testSys)
 	if err != nil {
 		t.Errorf("Expected no errors, got %v", err)
 	}
-	cancel()
 
 	// Bad case: GetRunningCoreSystemURL() returns error
 	newMockTransport(resp, 1, errHTTP)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, true) // true sets orchestrator url to a brokenURL
 	err = Search4Services(cer, &testSys)
 	if err == nil {
 		t.Errorf("Expected errors")
 	}
-	cancel()
 
 	// Bad case: Orchestrator url is ""
 	newMockTransport(resp, 0, nil)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
 	for i, cs := range testSys.CoreS {
 		if cs.Name == "orchestrator" {
 			(*testSys.CoreS[i]).Url = ""
@@ -409,37 +365,15 @@ func TestSearch4Services(t *testing.T) {
 	if err == nil {
 		t.Errorf("Expected errors")
 	}
-	cancel()
 
 	// Bad case: sendHttpReq() returns an error
 	newMockTransport(resp, 2, nil)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
+	testSys, _ = createTestSystem(false) // Needed otherwise we don't get past the orchestrator error handlers
 	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 	err = Search4Services(cer, &testSys)
 	if err == nil {
 		t.Errorf("Expected errors")
 	}
-	cancel()
-
-	// Bad case: Response status code is < 200 or >= 300
-	resp = func() *http.Response {
-		return &http.Response{
-			Status:     "199 ?",
-			StatusCode: 199,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(data))),
-		}
-	}
-	newMockTransport(resp, 4, errHTTP)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
-	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-	err = Search4Services(cer, &testSys)
-	if err == nil {
-		t.Errorf("Expected errors")
-	}
-	cancel()
 
 	// Bad case: io.ReadAll() return an error
 	resp = func() *http.Response {
@@ -451,14 +385,11 @@ func TestSearch4Services(t *testing.T) {
 		}
 	}
 	newMockTransport(resp, 0, nil)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
 	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 	err = Search4Services(cer, &testSys)
 	if err == nil {
 		t.Errorf("Expected errors")
 	}
-	cancel()
 
 	// Bad case: Unpack() returns an error and type assertion/conversion fails
 	resp = func() *http.Response {
@@ -470,15 +401,11 @@ func TestSearch4Services(t *testing.T) {
 		}
 	}
 	newMockTransport(resp, 0, nil)
-	ctx, cancel = context.WithCancel(context.Background())
-	testSys = createTestSystem(ctx, false)
 	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 	err = Search4Services(cer, &testSys)
 	if err == nil {
 		t.Errorf("Expected errors")
 	}
-	cancel()
-
 }
 
 func createTestServiceRecord(number int) (f forms.ServiceRecord_v1) {
diff --git a/usecases/utils_test.go b/usecases/utils_test.go
index 9defc85..d842e15 100644
--- a/usecases/utils_test.go
+++ b/usecases/utils_test.go
@@ -84,9 +84,10 @@ var brokenUrl = string([]byte{0x7f})
 var errHTTP error = fmt.Errorf("bad http request")
 
 // Help function to create a test system
-func createTestSystem(ctx context.Context, broken bool) components.System {
+func createTestSystem(broken bool) (sys components.System, ctx context.Context) {
 	// instantiate the System
-	sys := components.NewSystem("testSystem", ctx)
+	ctx = context.Background()
+	sys = components.NewSystem("testSystem", ctx)
 
 	// Instantiate the Capsule
 	sys.Husk = &components.Husk{
@@ -159,5 +160,5 @@ func createTestSystem(ctx context.Context, broken bool) components.System {
 			test,
 		}
 	}
-	return sys
+	return
 }

From 4dbebf606aa5e442e04958435483db89f89aecaa Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 17 Jun 2025 11:00:08 +0200
Subject: [PATCH 048/186] Fixed last comment of codereview, changed name of
 test utils file

---
 .../{utils_test.go => extra_utils_test.go}    |  0
 usecases/serviceDiscovery_test.go             | 95 ++++++++++---------
 2 files changed, 51 insertions(+), 44 deletions(-)
 rename usecases/{utils_test.go => extra_utils_test.go} (100%)

diff --git a/usecases/utils_test.go b/usecases/extra_utils_test.go
similarity index 100%
rename from usecases/utils_test.go
rename to usecases/extra_utils_test.go
diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 889e9b8..94303c8 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -48,65 +48,72 @@ type testBodyHasVersion struct {
 
 type testBodyNoVersion struct{}
 
-func createTestData(bodyType string, proto int, version string, errRead bool) (data []byte, err error) {
+type extractQuestFormParams struct {
+	testCase      string
+	expectedError bool
+	proto         int
+	version       string
+	errRead       bool
+	f             testBodyFunc //func(string, int, string) ([]byte, error)
+}
+
+type testBodyFunc func(int, string, bool) ([]byte, error)
+
+func createTestBodyHasProtocol(proto int, version string, errRead bool) ([]byte, error) {
 	if errRead == true {
 		return json.Marshal(errReader(0))
 	}
-	switch bodyType {
-	case "testBodyHasProtocol":
-		body := testBodyHasProtocol{
-			Protocol: proto,
-			Version:  version,
-		}
-		data, err := json.Marshal(body)
-		if err != nil {
-			return nil, err
-		}
-		return data, nil
-	case "testBodyHasVersion":
-		body := testBodyHasVersion{
-			Version: version,
-		}
-		data, err := json.Marshal(body)
-		if err != nil {
-			return nil, err
-		}
-		return data, nil
-	case "testBodyNoVersion":
-		body := testBodyNoVersion{}
-		data, err := json.Marshal(body)
-		if err != nil {
-			return nil, err
-		}
-		return data, nil
-	default:
-		return nil, errors.New("Body type not supported")
+	body := testBodyHasProtocol{
+		Protocol: proto,
+		Version:  version,
+	}
+	data, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
 	}
+	return data, nil
 }
 
-type extractQuestFormParams struct {
-	testCase      string
-	bodyType      string
-	protocol      int
-	version       string
-	errRead       bool
-	expectedError bool
+func createTestBodyHasVersion(proto int, version string, errRead bool) ([]byte, error) {
+	if errRead == true {
+		return json.Marshal(errReader(0))
+	}
+	body := testBodyHasVersion{
+		Version: version,
+	}
+	data, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+func createTestBodyHasNoVersion(proto int, version string, errRead bool) ([]byte, error) {
+	if errRead == true {
+		return json.Marshal(errReader(0))
+	}
+	body := testBodyNoVersion{}
+	data, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
 }
 
 func TestExtractQuestForm(t *testing.T) {
 	// A list holding structs containing the parameters used for the test
 	testParams := []extractQuestFormParams{
-		// {testCase, bodyType, protocol, version, errRead, expectedError}
 		// Always start with the "Best case, no errors"
-		{"No errors", "testBodyHasVersion", -1, "ServiceQuest_v1", false, false},
-		{"Error during Unmarshal", "testBodyHasVersion", -1, "ServiceQuest_v1", true, true},
-		{"Missing version", "testBodyNoVersion", -1, "", false, false},
-		{"Error while writing to correct form", "testBodyHasProtocol", 123, "ServiceQuest_v1", false, true},
-		{"Error Unsupported version", "testBodyHasVersion", -1, "", false, true},
+		// {testCase, expectedError, proto, version, errRead, data}
+		{"No errors", false, 123, "ServiceQuest_v1", false, createTestBodyHasVersion},
+		{"Error during Unmarshal", true, -1, "ServiceQuest_v1", true, createTestBodyHasVersion},
+		{"Missing version", false, -1, "", false, createTestBodyHasNoVersion},
+		{"Error while writing to correct form", true, 123, "ServiceQuest_v1", false, createTestBodyHasProtocol},
+		{"Error Unsupported version", true, -1, "", false, createTestBodyHasVersion},
 	}
 	for _, x := range testParams {
 		// Create the data []byte that will be sent into the function
-		data, err := createTestData(x.bodyType, x.protocol, x.version, x.errRead)
+		data, err := x.f(x.proto, x.version, x.errRead)
 		if err != nil {
 			t.Errorf("---\tError occurred while creating test data")
 		}

From 4750e91a08bcf37c493aa147885cb7136789a662 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 17 Jun 2025 11:17:30 +0200
Subject: [PATCH 049/186] changed a parameter for a test

---
 usecases/serviceDiscovery_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index 94303c8..b49511d 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -105,7 +105,7 @@ func TestExtractQuestForm(t *testing.T) {
 	testParams := []extractQuestFormParams{
 		// Always start with the "Best case, no errors"
 		// {testCase, expectedError, proto, version, errRead, data}
-		{"No errors", false, 123, "ServiceQuest_v1", false, createTestBodyHasVersion},
+		{"No errors", false, -1, "ServiceQuest_v1", false, createTestBodyHasVersion},
 		{"Error during Unmarshal", true, -1, "ServiceQuest_v1", true, createTestBodyHasVersion},
 		{"Missing version", false, -1, "", false, createTestBodyHasNoVersion},
 		{"Error while writing to correct form", true, 123, "ServiceQuest_v1", false, createTestBodyHasProtocol},

From 1e07a50e9e8950957b848c8512570cc1234f2815 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Tue, 17 Jun 2025 12:45:20 +0200
Subject: [PATCH 050/186] Changed the struct to take a general func() instead
 of a specific type

---
 usecases/serviceDiscovery_test.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index b49511d..fde0d76 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -54,11 +54,9 @@ type extractQuestFormParams struct {
 	proto         int
 	version       string
 	errRead       bool
-	f             testBodyFunc //func(string, int, string) ([]byte, error)
+	f             func(int, string, bool) ([]byte, error)
 }
 
-type testBodyFunc func(int, string, bool) ([]byte, error)
-
 func createTestBodyHasProtocol(proto int, version string, errRead bool) ([]byte, error) {
 	if errRead == true {
 		return json.Marshal(errReader(0))

From 1a94aaaead6ce9526b939eb36020a396212531a1 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Tue, 17 Jun 2025 13:11:31 +0200
Subject: [PATCH 051/186] Fixed test conflict

---
 usecases/extra_utils_test.go      |   4 +-
 usecases/serviceDiscovery_test.go |   8 +-
 usecases/utils_test.go            | 164 ------------------------------
 3 files changed, 6 insertions(+), 170 deletions(-)
 delete mode 100644 usecases/utils_test.go

diff --git a/usecases/extra_utils_test.go b/usecases/extra_utils_test.go
index d842e15..b66e783 100644
--- a/usecases/extra_utils_test.go
+++ b/usecases/extra_utils_test.go
@@ -84,9 +84,9 @@ var brokenUrl = string([]byte{0x7f})
 var errHTTP error = fmt.Errorf("bad http request")
 
 // Help function to create a test system
-func createTestSystem(broken bool) (sys components.System, ctx context.Context) {
+func createTestSystem(broken bool) (sys components.System) {
 	// instantiate the System
-	ctx = context.Background()
+	ctx := context.Background()
 	sys = components.NewSystem("testSystem", ctx)
 
 	// Instantiate the Capsule
diff --git a/usecases/serviceDiscovery_test.go b/usecases/serviceDiscovery_test.go
index fde0d76..47dd932 100644
--- a/usecases/serviceDiscovery_test.go
+++ b/usecases/serviceDiscovery_test.go
@@ -26,7 +26,7 @@ func TestServQuestForms(t *testing.T) {
 }
 
 func TestFillQuestForm(t *testing.T) {
-	testSys, _ := createTestSystem(false)
+	testSys := createTestSystem(false)
 	mua := mockUnitAsset{}
 	questForm := FillQuestForm(&testSys, mua, "TestDef", "TestProtocol")
 	// Loop through the details in questForm and mua (mockUnitAsset), error if they're not the same
@@ -229,7 +229,7 @@ func TestSearch4Service(t *testing.T) {
 		}
 	}
 	newMockTransport(resp, 0, nil)
-	testSys, _ := createTestSystem(false)
+	testSys := createTestSystem(false)
 	var qForm forms.ServiceQuest_v1
 	serviceForm, err := Search4Service(qForm, &testSys)
 	if err != nil {
@@ -344,7 +344,7 @@ func TestSearch4Services(t *testing.T) {
 		}
 	}
 	newMockTransport(resp, 0, nil)
-	testSys, _ := createTestSystem(false)
+	testSys := createTestSystem(false)
 	cer := (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 	err = Search4Services(cer, &testSys)
 	if err != nil {
@@ -373,7 +373,7 @@ func TestSearch4Services(t *testing.T) {
 
 	// Bad case: sendHttpReq() returns an error
 	newMockTransport(resp, 2, nil)
-	testSys, _ = createTestSystem(false) // Needed otherwise we don't get past the orchestrator error handlers
+	testSys = createTestSystem(false) // Needed otherwise we don't get past the orchestrator error handlers
 	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 	err = Search4Services(cer, &testSys)
 	if err == nil {
diff --git a/usecases/utils_test.go b/usecases/utils_test.go
deleted file mode 100644
index 4880c3c..0000000
--- a/usecases/utils_test.go
+++ /dev/null
@@ -1,164 +0,0 @@
-package usecases
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-
-	"github.com/sdoque/mbaigo/components"
-)
-
-// mockTransport is used for replacing the default network Transport (used by
-// http.DefaultClient) and it will intercept network requests.
-type mockTransport struct {
-	respFunc func() *http.Response
-	hits     int
-	err      error
-}
-
-func newMockTransport(respFunc func() *http.Response, v int, err error) *mockTransport {
-	t := &mockTransport{
-		respFunc: respFunc,
-		hits:     v,
-		err:      err,
-	}
-	// Hijack the default http client so no actual http requests are sent over the network
-	http.DefaultClient.Transport = t
-	return t
-}
-
-// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
-// It prevents the request from being sent over the network, and count how many times
-// a http request was sent
-func (t *mockTransport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-	t.hits -= 1
-	if t.hits == 0 {
-		return nil, t.err
-	}
-	resp = t.respFunc()
-	resp.Request = req
-	return resp, nil
-}
-
-// A mocked UnitAsset used for testing
-type mockUnitAsset struct {
-	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
-	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
-	Details     map[string][]string `json:"details"` // Metadata or details about this UA
-	ServicesMap components.Services `json:"-"`
-	CervicesMap components.Cervices `json:"-"`
-}
-
-func (mua mockUnitAsset) GetName() string {
-	return mua.Name
-}
-
-func (mua mockUnitAsset) GetServices() components.Services {
-	return mua.ServicesMap
-}
-
-func (mua mockUnitAsset) GetCervices() components.Cervices {
-	return mua.CervicesMap
-}
-
-func (mua mockUnitAsset) GetDetails() map[string][]string {
-	return mua.Details
-}
-
-func (mua mockUnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {}
-
-// Create a error reader to break json.Unmarshal()
-type errReader int
-
-var errBodyRead error = fmt.Errorf("bad body read")
-
-func (errReader) Read(p []byte) (n int, err error) {
-	return 0, errBodyRead
-}
-func (errReader) Close() error {
-	return nil
-}
-
-// Variables used in testing
-var brokenUrl = string([]byte{0x7f})
-var errHTTP error = fmt.Errorf("bad http request")
-
-// Help function to create a test system
-func createTestSystem(broken bool) components.System {
-	// instantiate the System
-	ctx := context.Background()
-	sys := components.NewSystem("testSystem", ctx)
-
-	// Instantiate the Capsule
-	sys.Husk = &components.Husk{
-		Description: "A test system",
-		Details:     map[string][]string{"Developer": {"Test dev"}},
-		ProtoPort:   map[string]int{"https": 0, "http": 1234, "coap": 0},
-		InfoLink:    "https://for.testing.purposes",
-	}
-
-	// create fake services and cervices for a mocked unit asset
-	testCerv := &components.Cervice{
-		Definition: "testCerv",
-		Details:    map[string][]string{"Forms": {"SignalA_v1a"}},
-		Nodes:      map[string][]string{},
-	}
-
-	CervicesMap := &components.Cervices{
-		testCerv.Definition: testCerv,
-	}
-	setTest := &components.Service{
-		ID:            1,
-		Definition:    "test",
-		SubPath:       "test",
-		Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
-		Description:   "A test service",
-		RegPeriod:     45,
-		RegTimestamp:  "now",
-		RegExpiration: "45",
-	}
-	ServicesMap := &components.Services{
-		setTest.SubPath: setTest,
-	}
-	mua := &mockUnitAsset{
-		Name:        "testUnitAsset",
-		Details:     map[string][]string{"Test": {"Test"}},
-		ServicesMap: *ServicesMap,
-		CervicesMap: *CervicesMap,
-	}
-
-	sys.UAssets = make(map[string]*components.UnitAsset)
-	var muaInterface components.UnitAsset = mua
-	sys.UAssets[mua.GetName()] = &muaInterface
-
-	leadingRegistrar := &components.CoreSystem{
-		Name: "serviceregistrar",
-		Url:  "https://leadingregistrar",
-	}
-	test := &components.CoreSystem{
-		Name: "test",
-		Url:  "https://test",
-	}
-	if broken == false {
-		orchestrator := &components.CoreSystem{
-			Name: "orchestrator",
-			Url:  "https://orchestator",
-		}
-		sys.CoreS = []*components.CoreSystem{
-			leadingRegistrar,
-			orchestrator,
-			test,
-		}
-	} else {
-		orchestrator := &components.CoreSystem{
-			Name: "orchestrator",
-			Url:  brokenUrl,
-		}
-		sys.CoreS = []*components.CoreSystem{
-			leadingRegistrar,
-			orchestrator,
-			test,
-		}
-	}
-	return sys
-}

From f49b7831075925f468949e4ea2a8725b19dd3327 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 19 Jun 2025 12:38:23 +0200
Subject: [PATCH 052/186] Fixes go build caching in the workflow

If `go.sum` is missing, setup-go won't restore the cache!
---
 .github/workflows/main.yml | 4 ++--
 Makefile                   | 3 +--
 go.sum                     | 0
 3 files changed, 3 insertions(+), 4 deletions(-)
 create mode 100644 go.sum

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index e365fbd..623db7e 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -15,7 +15,7 @@ jobs:
       - name: Setup go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.23
+          go-version-file: go.mod
       - name: Install dependencies
         run: make linterinstall
       - name: Run linters
@@ -36,7 +36,7 @@ jobs:
       - name: Setup go
         uses: actions/setup-go@v5
         with:
-          go-version: 1.23
+          go-version-file: go.mod
       - name: Install dependencies
         run: make modinstall
       - name: Run tests
diff --git a/Makefile b/Makefile
index 39e4531..dccec6a 100644
--- a/Makefile
+++ b/Makefile
@@ -7,8 +7,7 @@ lint:
 	test -z $$(gofmt -l .) || (echo "Code isn't gofmt'ed!" && exit 1)
 	go vet $$(go list ./... | grep -v /tmp)
 	gosec -quiet -fmt=golint -exclude-dir="tmp" ./...
-
-# pointerinterface ./...
+	# pointerinterface ./...
 
 # Runs spellchecker on the code and comments
 # This requires this tool to be installed from https://github.com/crate-ci/typos?tab=readme-ov-file
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..e69de29

From 52804ac2cb1714a49cac0f2f1dde49e67cfabbd6 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 19 Jun 2025 16:00:53 +0200
Subject: [PATCH 053/186] Merges lint/test jobs so they can share the cache
 properly

---
 .github/workflows/main.yml | 24 +++++-------------------
 Makefile                   |  6 ++----
 2 files changed, 7 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 623db7e..867ec08 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 jobs:
-  Linters:
+  LintnTest:
     runs-on: ubuntu-latest
     timeout-minutes: 2
     steps:
@@ -17,29 +17,15 @@ jobs:
         with:
           go-version-file: go.mod
       - name: Install dependencies
-        run: make linterinstall
+        run: make installpkgs
       - name: Run linters
         run: make lint
+      - name: Run tests
+        run: make test
 
   Spellcheck:
     runs-on: ubuntu-latest
-    timeout-minutes: 2
+    timeout-minutes: 1
     steps:
       - uses: actions/checkout@v4
       - uses: crate-ci/typos@v1.29.7
-
-  Tests:
-    runs-on: ubuntu-latest
-    timeout-minutes: 2
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup go
-        uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-      - name: Install dependencies
-        run: make modinstall
-      - name: Run tests
-        run: make test
-      - name: Report stats
-        run: make analyse
diff --git a/Makefile b/Makefile
index dccec6a..0a06467 100644
--- a/Makefile
+++ b/Makefile
@@ -27,12 +27,10 @@ analyse:
 	gocyclo -avg -top 10 -ignore test.go .
 
 # Updates 3rd party packages and tools
-modinstall:
+installpkgs:
 	go mod download
-	go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
-
-linterinstall:
 	go install github.com/securego/gosec/v2/cmd/gosec@latest
+	go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
 	go install code.larus.se/lmas/pointerinterface@latest
 
 # Clean up built binary and other temporary files (ignores errors from rm)

From c28ce5d996f065e77cca6eb35968247065400171 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Tue, 17 Jun 2025 19:00:06 +0200
Subject: [PATCH 054/186] Started working on tests for consumption.go

---
 usecases/consumption.go      |  17 ++-
 usecases/consumption_test.go | 264 +++++++++++++++++++++++++++++++++++
 2 files changed, 275 insertions(+), 6 deletions(-)
 create mode 100644 usecases/consumption_test.go

diff --git a/usecases/consumption.go b/usecases/consumption.go
index b983ec8..c9ca854 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -41,7 +41,8 @@ func GetState(cer *components.Cervice, sys *components.System) (f forms.Form, er
 			return f, err
 		}
 	}
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) // Create a new context, with a 2-second timeout
+	// ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second) // Create a new context, with a 2-second timeout
 	defer cancel()
 	// Create a new HTTP request using the first known provider
 	var serviceUrl string
@@ -58,8 +59,9 @@ func GetState(cer *components.Cervice, sys *components.System) (f forms.Form, er
 	// Associate the cancellable context with the request
 	req = req.WithContext(ctx)
 	// Send the request /////////////////////////////////
-	client := &http.Client{}
-	resp, err := client.Do(req)
+	//client := &http.Client{}
+	//resp, err := client.Do(req)
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		cer.Nodes = make(map[string][]string) // failed to get the resource at that location: reset the providers list, which will trigger a new service search
 		return f, err
@@ -81,6 +83,7 @@ func GetState(cer *components.Cervice, sys *components.System) (f forms.Form, er
 	f, err = Unpack(bodyBytes, headerContentTtype)
 	if err != nil {
 		fmt.Printf("error unpacking the service response: %s", err)
+		return f, err
 	}
 	return f, nil
 }
@@ -96,7 +99,8 @@ func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte)
 	}
 
 	// Create a new context, with a 2-second timeout
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	// ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second)
 	defer cancel()
 
 	// Create a new HTTP request
@@ -118,8 +122,9 @@ func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte)
 	req = req.WithContext(ctx)
 
 	// Send the request
-	client := &http.Client{}
-	resp, err := client.Do(req)
+	//client := &http.Client{}
+	//resp, err := client.Do(req)
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		cer.Nodes = make(map[string][]string) // Failed to get the resource at that location: reset the providers list, which will trigger a new service search
 		return f, err
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
new file mode 100644
index 0000000..1e17eaf
--- /dev/null
+++ b/usecases/consumption_test.go
@@ -0,0 +1,264 @@
+package usecases
+
+import (
+	//"encoding/json"
+	//"fmt"
+	//"io"
+	//"reflect"
+	//"strings"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	//"time"
+
+	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/forms"
+)
+
+type stateParams struct {
+	testCase         string
+	testCer          *components.Cervice
+	testSys          *components.System
+	bodyBytes        []byte
+	body             func() *http.Response
+	mockTransportErr int
+	errHTTP          error
+	expectedfForm    forms.Form
+	expectedErr      error
+}
+
+func newTestCerviceWithNodes() *components.Cervice {
+	return &components.Cervice{
+		IReferentce: "test",
+		Definition:  "A test Cervice with nodes",
+		Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
+		Nodes:       map[string][]string{"test": {"https://testSystem/testUnitAsset/test"}},
+		Protos:      []string{"http"},
+	}
+}
+
+var testCerviceWithNodesRefresh = components.Cervice{
+	IReferentce: "test",
+	Definition:  "A test Cervice with nodes",
+	Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
+	Nodes:       map[string][]string{"test": {"https://testSystem/testUnitAsset/test"}},
+	Protos:      []string{"http"},
+}
+
+var testCerviceWithoutNodes = components.Cervice{
+	IReferentce: "test",
+	Definition:  "A test Cervice without nodes",
+	Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
+	Nodes:       nil,
+	Protos:      []string{"http"},
+}
+
+var testCerviceWithBrokenUrl = components.Cervice{
+	IReferentce: "test",
+	Definition:  "A test Cervice with nodes",
+	Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
+	Nodes:       map[string][]string{"test": {brokenUrl}},
+	Protos:      []string{"http"},
+}
+
+var testSys = createTestSystem(false)
+
+var form forms.SignalA_v1a
+
+var testStateParams = []stateParams{
+	{
+		"No errors",
+		newTestCerviceWithNodes(),
+		&testSys,
+		nil,
+		func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			}
+		},
+		0,
+		nil,
+		form.NewForm(),
+		nil,
+	},
+	{
+		"No errors",
+		&testCerviceWithoutNodes,
+		&testSys,
+		nil,
+		func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			}
+		},
+		0,
+		nil,
+		form.NewForm(),
+		nil,
+	},
+	{
+		"Search4Services error",
+		&testCerviceWithoutNodes,
+		&testSys,
+		nil,
+		func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			}
+		},
+		1,
+		errHTTP,
+		nil,
+		errHTTP,
+	},
+	{
+		"NewRequest() error",
+		&testCerviceWithBrokenUrl,
+		&testSys,
+		nil,
+		func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			}
+		},
+		1,
+		errHTTP,
+		nil,
+		errHTTP,
+	},
+	{
+		"Status code error",
+		newTestCerviceWithNodes(),
+		&testSys,
+		nil,
+		func() *http.Response {
+			return &http.Response{
+				Status:     "300 NAK",
+				StatusCode: 300,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			}
+		},
+		2,
+		errHTTP,
+		nil,
+		errHTTP,
+	},
+	{
+		"io.ReadAll() error",
+		newTestCerviceWithNodes(),
+		&testSys,
+		nil,
+		func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(errorReader{}),
+			}
+		},
+		0,
+		nil,
+		nil,
+		nil,
+	},
+	{
+		"Unpack() error",
+		newTestCerviceWithNodes(),
+		&testSys,
+		nil,
+		func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"Wrong content type"}},
+				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			}
+		},
+		0,
+		nil,
+		nil,
+		nil,
+	},
+	{
+		"DefaultClient.Do() error",
+		newTestCerviceWithNodes(),
+		&testSys,
+		nil,
+		func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			}
+		},
+		1,
+		errHTTP,
+		nil,
+		errHTTP,
+	},
+}
+
+func TestGetState(t *testing.T) {
+	for _, test := range testStateParams {
+		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
+
+		res, err := GetState(test.testCer, test.testSys)
+
+		// Directly compare the fields of the expected and actual forms
+		if res != nil {
+			expected := test.expectedfForm.(*forms.SignalA_v1a)
+			actual := res.(*forms.SignalA_v1a)
+			if test.testCase == "No errors" {
+				if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
+					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
+				}
+			}
+		} else {
+			if err == nil {
+				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
+			}
+		}
+	}
+}
+
+func TestSetState(t *testing.T) {
+	for _, test := range testStateParams {
+		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
+
+		if test.testCase == "DefaultClient.Do() error" {
+			test.testCer = &testCerviceWithNodesRefresh
+		}
+		res, err := SetState(test.testCer, test.testSys, nil)
+
+		// Directly compare the fields of the expected and actual forms
+		if res != nil {
+			expected := test.expectedfForm.(*forms.SignalA_v1a)
+			actual := res.(*forms.SignalA_v1a)
+			if test.testCase == "No errors" {
+				if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
+					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
+				}
+			}
+		} else {
+			if err == nil {
+				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
+			}
+		}
+	}
+}

From 2100ea9fbe0e34f9bc458d2db1a929092d9c9cb9 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Wed, 18 Jun 2025 14:33:34 +0200
Subject: [PATCH 055/186] Added test cases for SetState function

---
 usecases/consumption_test.go | 104 +++++++++++++++++++++++++++++++----
 1 file changed, 94 insertions(+), 10 deletions(-)

diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index 1e17eaf..0b8a153 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -72,7 +72,7 @@ var testStateParams = []stateParams{
 		"No errors",
 		newTestCerviceWithNodes(),
 		&testSys,
-		nil,
+		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
 		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
@@ -90,7 +90,7 @@ var testStateParams = []stateParams{
 		"No errors",
 		&testCerviceWithoutNodes,
 		&testSys,
-		nil,
+		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
 		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
@@ -104,11 +104,29 @@ var testStateParams = []stateParams{
 		form.NewForm(),
 		nil,
 	},
+	{
+		"No errors SetState",
+		newTestCerviceWithNodes(),
+		&testSys,
+		nil,
+		func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string(""))),
+			}
+		},
+		0,
+		nil,
+		form.NewForm(),
+		nil,
+	},
 	{
 		"Search4Services error",
 		&testCerviceWithoutNodes,
 		&testSys,
-		nil,
+		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
 		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
@@ -126,7 +144,7 @@ var testStateParams = []stateParams{
 		"NewRequest() error",
 		&testCerviceWithBrokenUrl,
 		&testSys,
-		nil,
+		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
 		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
@@ -144,7 +162,7 @@ var testStateParams = []stateParams{
 		"Status code error",
 		newTestCerviceWithNodes(),
 		&testSys,
-		nil,
+		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
 		func() *http.Response {
 			return &http.Response{
 				Status:     "300 NAK",
@@ -162,7 +180,7 @@ var testStateParams = []stateParams{
 		"io.ReadAll() error",
 		newTestCerviceWithNodes(),
 		&testSys,
-		nil,
+		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
 		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
@@ -180,7 +198,7 @@ var testStateParams = []stateParams{
 		"Unpack() error",
 		newTestCerviceWithNodes(),
 		&testSys,
-		nil,
+		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
 		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
@@ -198,7 +216,7 @@ var testStateParams = []stateParams{
 		"DefaultClient.Do() error",
 		newTestCerviceWithNodes(),
 		&testSys,
-		nil,
+		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
 		func() *http.Response {
 			return &http.Response{
 				Status:     "200 OK",
@@ -218,10 +236,15 @@ func TestGetState(t *testing.T) {
 	for _, test := range testStateParams {
 		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
 
+		// No need to test this as the test is specifically for SetState
+		if test.testCase == "No errors SetState" {
+			continue
+		}
+
 		res, err := GetState(test.testCer, test.testSys)
 
 		// Directly compare the fields of the expected and actual forms
-		if res != nil {
+		if res != nil && test.bodyBytes != nil {
 			expected := test.expectedfForm.(*forms.SignalA_v1a)
 			actual := res.(*forms.SignalA_v1a)
 			if test.testCase == "No errors" {
@@ -247,7 +270,40 @@ func TestSetState(t *testing.T) {
 		res, err := SetState(test.testCer, test.testSys, nil)
 
 		// Directly compare the fields of the expected and actual forms
-		if res != nil {
+		if res != nil && test.bodyBytes != nil {
+			expected := test.expectedfForm.(*forms.SignalA_v1a)
+			actual := res.(*forms.SignalA_v1a)
+			if test.testCase == "No errors" {
+				if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
+					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
+				}
+			}
+		} else if test.bodyBytes == nil {
+			if err != nil && res != nil {
+				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
+			}
+		}
+	}
+}
+
+/*
+func TestForstateHandler(t *testing.T) {
+	for _, test := range testStateParams {
+		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
+
+		// No need to test this as the test is specifically for SetState
+		if test.testCase == "No errors SetState" {
+			continue
+		}
+
+		res, err := GetState(test.testCer, test.testSys)
+
+		// Directly compare the fields of the expected and actual forms
+		if res != nil && test.bodyBytes != nil {
 			expected := test.expectedfForm.(*forms.SignalA_v1a)
 			actual := res.(*forms.SignalA_v1a)
 			if test.testCase == "No errors" {
@@ -261,4 +317,32 @@ func TestSetState(t *testing.T) {
 			}
 		}
 	}
+	for _, test := range testStateParams {
+		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
+
+		if test.testCase == "DefaultClient.Do() error" {
+			test.testCer = &testCerviceWithNodesRefresh
+		}
+		res, err := SetState(test.testCer, test.testSys, test.bodyBytes)
+
+		// Directly compare the fields of the expected and actual forms
+		if res != nil && test.bodyBytes != nil {
+			expected := test.expectedfForm.(*forms.SignalA_v1a)
+			actual := res.(*forms.SignalA_v1a)
+			if test.testCase == "No errors" {
+				if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
+					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
+				}
+			}
+		} else if test.bodyBytes == nil {
+			if err != nil && res != nil {
+				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
+			}
+		}
+	}
 }
+*/

From 8802b7efc8bf1637bcb31f0577666296d01bfa21 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Wed, 18 Jun 2025 14:35:32 +0200
Subject: [PATCH 056/186] Refactored consumption.go so there is a general
 stateHandler which both GetState and SetState uses

---
 usecases/consumption.go | 220 ++++++++++++++++++++++++++++------------
 1 file changed, 153 insertions(+), 67 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index c9ca854..6df77a6 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -24,7 +24,8 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"log"
+
+	//"log"
 	"net/http"
 	"time"
 
@@ -34,63 +35,151 @@ import (
 
 // GetState request the current state of a unit asset (via the asset's service)
 func GetState(cer *components.Cervice, sys *components.System) (f forms.Form, err error) {
-	// if no known providers, search for one via the Orchestrator
-	if len(cer.Nodes) == 0 {
-		err := Search4Services(cer, sys)
-		if err != nil {
-			return f, err
-		}
-	}
-	// ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second) // Create a new context, with a 2-second timeout
-	defer cancel()
-	// Create a new HTTP request using the first known provider
-	var serviceUrl string
-	for _, values := range cer.Nodes {
-		if len(values) > 0 {
-			serviceUrl = values[0]
-			break
-		}
-	}
-	req, err := http.NewRequest(http.MethodGet, serviceUrl, nil)
-	if err != nil {
-		return f, err
-	}
-	// Associate the cancellable context with the request
-	req = req.WithContext(ctx)
-	// Send the request /////////////////////////////////
-	//client := &http.Client{}
-	//resp, err := client.Do(req)
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		cer.Nodes = make(map[string][]string) // failed to get the resource at that location: reset the providers list, which will trigger a new service search
-		return f, err
-	}
-	defer resp.Body.Close()
-
-	// Check if the status code indicates an error (anything outside the 200–299 range)
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return f, fmt.Errorf("received non-2xx status code: %d, response: %s", resp.StatusCode, http.StatusText(resp.StatusCode))
-	}
-
-	bodyBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		log.Printf("GetRValue-Error reading registration response body: %v", err)
-		return
-	}
-
-	headerContentTtype := resp.Header.Get("Content-Type")
-	f, err = Unpack(bodyBytes, headerContentTtype)
-	if err != nil {
-		fmt.Printf("error unpacking the service response: %s", err)
-		return f, err
-	}
-	return f, nil
+	return stateHandler(http.MethodGet, cer, sys, nil)
+	/*
+	   // if no known providers, search for one via the Orchestrator
+
+	   	if len(cer.Nodes) == 0 {
+	   		err := Search4Services(cer, sys)
+	   		if err != nil {
+	   			return f, err
+	   		}
+	   	}
+
+	   // ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	   ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second) // Create a new context, with a 2-second timeout
+	   defer cancel()
+	   // Create a new HTTP request using the first known provider
+	   var serviceUrl string
+
+	   	for _, values := range cer.Nodes {
+	   		if len(values) > 0 {
+	   			serviceUrl = values[0]
+	   			break
+	   		}
+	   	}
+
+	   req, err := http.NewRequest(http.MethodGet, serviceUrl, nil)
+
+	   	if err != nil {
+	   		return f, err
+	   	}
+
+	   // Associate the cancellable context with the request
+	   req = req.WithContext(ctx)
+	   // Send the request /////////////////////////////////
+	   //client := &http.Client{}
+	   //resp, err := client.Do(req)
+	   resp, err := http.DefaultClient.Do(req)
+
+	   	if err != nil {
+	   		cer.Nodes = make(map[string][]string) // failed to get the resource at that location: reset the providers list, which will trigger a new service search
+	   		return f, err
+	   	}
+
+	   defer resp.Body.Close()
+
+	   // Check if the status code indicates an error (anything outside the 200–299 range)
+
+	   	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+	   		return f, fmt.Errorf("received non-2xx status code: %d, response: %s", resp.StatusCode, http.StatusText(resp.StatusCode))
+	   	}
+
+	   bodyBytes, err := io.ReadAll(resp.Body)
+
+	   	if err != nil {
+	   		log.Printf("GetRValue-Error reading registration response body: %v", err)
+	   		return
+	   	}
+
+	   headerContentTtype := resp.Header.Get("Content-Type")
+	   f, err = Unpack(bodyBytes, headerContentTtype)
+
+	   	if err != nil {
+	   		fmt.Printf("error unpacking the service response: %s", err)
+	   		return f, err
+	   	}
+
+	   return f, nil
+	*/
 }
 
 // SetState puts a request to change the state of a unit asset (via the asset's service)
 func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte) (f forms.Form, err error) {
-	// Get the address of the informing service of the target asset via the Orchestrator
+	return stateHandler(http.MethodPut, cer, sys, bodyBytes)
+	/*
+	   // Get the address of the informing service of the target asset via the Orchestrator
+
+	   	if len(cer.Nodes) == 0 {
+	   		err := Search4Services(cer, sys)
+	   		if err != nil {
+	   			return f, err
+	   		}
+	   	}
+
+	   // Create a new context, with a 2-second timeout
+	   // ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	   ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second)
+	   defer cancel()
+
+	   // Create a new HTTP request
+	   var serviceUrl string
+
+	   	for _, values := range cer.Nodes {
+	   		if len(values) > 0 {
+	   			serviceUrl = values[0]
+	   			break
+	   		}
+	   	}
+
+	   req, err := http.NewRequest(http.MethodPut, serviceUrl, bytes.NewReader(bodyBytes))
+
+	   	if err != nil {
+	   		return f, err
+	   	}
+
+	   // Set the Content-Type header
+	   req.Header.Set("Content-Type", "application/json")
+	   // Associate the cancellable context with the request
+	   req = req.WithContext(ctx)
+
+	   // Send the request
+	   //client := &http.Client{}
+	   //resp, err := client.Do(req)
+	   resp, err := http.DefaultClient.Do(req)
+
+	   	if err != nil {
+	   		cer.Nodes = make(map[string][]string) // Failed to get the resource at that location: reset the providers list, which will trigger a new service search
+	   		return f, err
+	   	}
+
+	   defer resp.Body.Close()
+
+	   // Check if the status code indicates an error (anything outside the 200–299 range)
+
+	   	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+	   		return f, fmt.Errorf("received non-2xx status code: %d, response: %s", resp.StatusCode, http.StatusText(resp.StatusCode))
+	   	}
+
+	   // If the response includes a payload, unpack it into a forms.Form
+	   bodyBytes, err = io.ReadAll(resp.Body)
+
+	   	if err != nil {
+	   		return f, fmt.Errorf("error reading response body: %v", err)
+	   	}
+
+	   	if len(bodyBytes) > 0 {
+	   		headerContentType := resp.Header.Get("Content-Type")
+	   		f, err = Unpack(bodyBytes, headerContentType)
+	   		if err != nil {
+	   			return f, fmt.Errorf("error unpacking the service response: %v", err)
+	   		}
+	   	}
+
+	   return f, nil
+	*/
+}
+func stateHandler(httpMethod string, cer *components.Cervice, sys *components.System, bodyBytes []byte) (f forms.Form, err error) {
 	if len(cer.Nodes) == 0 {
 		err := Search4Services(cer, sys)
 		if err != nil {
@@ -98,12 +187,10 @@ func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte)
 		}
 	}
 
-	// Create a new context, with a 2-second timeout
 	// ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second) // Create a new context, with a 2-second timeout
 	defer cancel()
 
-	// Create a new HTTP request
 	var serviceUrl string
 	for _, values := range cer.Nodes {
 		if len(values) > 0 {
@@ -111,22 +198,21 @@ func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte)
 			break
 		}
 	}
-	req, err := http.NewRequest(http.MethodPut, serviceUrl, bytes.NewReader(bodyBytes))
+
+	req, err := http.NewRequest(httpMethod, serviceUrl, bytes.NewReader(bodyBytes))
 	if err != nil {
 		return f, err
 	}
 
-	// Set the Content-Type header
-	req.Header.Set("Content-Type", "application/json")
-	// Associate the cancellable context with the request
+	if httpMethod == "PUT" {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
 	req = req.WithContext(ctx)
 
-	// Send the request
-	//client := &http.Client{}
-	//resp, err := client.Do(req)
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
-		cer.Nodes = make(map[string][]string) // Failed to get the resource at that location: reset the providers list, which will trigger a new service search
+		cer.Nodes = make(map[string][]string)
 		return f, err
 	}
 	defer resp.Body.Close()
@@ -139,14 +225,14 @@ func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte)
 	// If the response includes a payload, unpack it into a forms.Form
 	bodyBytes, err = io.ReadAll(resp.Body)
 	if err != nil {
-		return f, fmt.Errorf("error reading response body: %v", err)
+		return f, fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if len(bodyBytes) > 0 {
 		headerContentType := resp.Header.Get("Content-Type")
 		f, err = Unpack(bodyBytes, headerContentType)
 		if err != nil {
-			return f, fmt.Errorf("error unpacking the service response: %v", err)
+			return f, fmt.Errorf("error unpacking the service response: %w", err)
 		}
 	}
 

From 4214a829d26f5d7a0f337b03024750da4e94ccf0 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 23 Jun 2025 14:32:09 +0200
Subject: [PATCH 057/186] Made changes according to the requested changes in
 pull request

---
 usecases/consumption.go      | 180 +------------------
 usecases/consumption_test.go | 325 +++++++++++++++--------------------
 2 files changed, 145 insertions(+), 360 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index 6df77a6..b8e5bb6 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -20,14 +20,10 @@
 package usecases
 
 import (
-	"bytes"
-	"context"
 	"fmt"
 	"io"
 
-	//"log"
 	"net/http"
-	"time"
 
 	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
@@ -36,149 +32,13 @@ import (
 // GetState request the current state of a unit asset (via the asset's service)
 func GetState(cer *components.Cervice, sys *components.System) (f forms.Form, err error) {
 	return stateHandler(http.MethodGet, cer, sys, nil)
-	/*
-	   // if no known providers, search for one via the Orchestrator
-
-	   	if len(cer.Nodes) == 0 {
-	   		err := Search4Services(cer, sys)
-	   		if err != nil {
-	   			return f, err
-	   		}
-	   	}
-
-	   // ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	   ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second) // Create a new context, with a 2-second timeout
-	   defer cancel()
-	   // Create a new HTTP request using the first known provider
-	   var serviceUrl string
-
-	   	for _, values := range cer.Nodes {
-	   		if len(values) > 0 {
-	   			serviceUrl = values[0]
-	   			break
-	   		}
-	   	}
-
-	   req, err := http.NewRequest(http.MethodGet, serviceUrl, nil)
-
-	   	if err != nil {
-	   		return f, err
-	   	}
-
-	   // Associate the cancellable context with the request
-	   req = req.WithContext(ctx)
-	   // Send the request /////////////////////////////////
-	   //client := &http.Client{}
-	   //resp, err := client.Do(req)
-	   resp, err := http.DefaultClient.Do(req)
-
-	   	if err != nil {
-	   		cer.Nodes = make(map[string][]string) // failed to get the resource at that location: reset the providers list, which will trigger a new service search
-	   		return f, err
-	   	}
-
-	   defer resp.Body.Close()
-
-	   // Check if the status code indicates an error (anything outside the 200–299 range)
-
-	   	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-	   		return f, fmt.Errorf("received non-2xx status code: %d, response: %s", resp.StatusCode, http.StatusText(resp.StatusCode))
-	   	}
-
-	   bodyBytes, err := io.ReadAll(resp.Body)
-
-	   	if err != nil {
-	   		log.Printf("GetRValue-Error reading registration response body: %v", err)
-	   		return
-	   	}
-
-	   headerContentTtype := resp.Header.Get("Content-Type")
-	   f, err = Unpack(bodyBytes, headerContentTtype)
-
-	   	if err != nil {
-	   		fmt.Printf("error unpacking the service response: %s", err)
-	   		return f, err
-	   	}
-
-	   return f, nil
-	*/
 }
 
 // SetState puts a request to change the state of a unit asset (via the asset's service)
 func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte) (f forms.Form, err error) {
 	return stateHandler(http.MethodPut, cer, sys, bodyBytes)
-	/*
-	   // Get the address of the informing service of the target asset via the Orchestrator
-
-	   	if len(cer.Nodes) == 0 {
-	   		err := Search4Services(cer, sys)
-	   		if err != nil {
-	   			return f, err
-	   		}
-	   	}
-
-	   // Create a new context, with a 2-second timeout
-	   // ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	   ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second)
-	   defer cancel()
-
-	   // Create a new HTTP request
-	   var serviceUrl string
-
-	   	for _, values := range cer.Nodes {
-	   		if len(values) > 0 {
-	   			serviceUrl = values[0]
-	   			break
-	   		}
-	   	}
-
-	   req, err := http.NewRequest(http.MethodPut, serviceUrl, bytes.NewReader(bodyBytes))
-
-	   	if err != nil {
-	   		return f, err
-	   	}
-
-	   // Set the Content-Type header
-	   req.Header.Set("Content-Type", "application/json")
-	   // Associate the cancellable context with the request
-	   req = req.WithContext(ctx)
-
-	   // Send the request
-	   //client := &http.Client{}
-	   //resp, err := client.Do(req)
-	   resp, err := http.DefaultClient.Do(req)
-
-	   	if err != nil {
-	   		cer.Nodes = make(map[string][]string) // Failed to get the resource at that location: reset the providers list, which will trigger a new service search
-	   		return f, err
-	   	}
-
-	   defer resp.Body.Close()
-
-	   // Check if the status code indicates an error (anything outside the 200–299 range)
-
-	   	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-	   		return f, fmt.Errorf("received non-2xx status code: %d, response: %s", resp.StatusCode, http.StatusText(resp.StatusCode))
-	   	}
-
-	   // If the response includes a payload, unpack it into a forms.Form
-	   bodyBytes, err = io.ReadAll(resp.Body)
-
-	   	if err != nil {
-	   		return f, fmt.Errorf("error reading response body: %v", err)
-	   	}
-
-	   	if len(bodyBytes) > 0 {
-	   		headerContentType := resp.Header.Get("Content-Type")
-	   		f, err = Unpack(bodyBytes, headerContentType)
-	   		if err != nil {
-	   			return f, fmt.Errorf("error unpacking the service response: %v", err)
-	   		}
-	   	}
-
-	   return f, nil
-	*/
 }
+
 func stateHandler(httpMethod string, cer *components.Cervice, sys *components.System, bodyBytes []byte) (f forms.Form, err error) {
 	if len(cer.Nodes) == 0 {
 		err := Search4Services(cer, sys)
@@ -187,10 +47,6 @@ func stateHandler(httpMethod string, cer *components.Cervice, sys *components.Sy
 		}
 	}
 
-	// ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Second) // Create a new context, with a 2-second timeout
-	defer cancel()
-
 	var serviceUrl string
 	for _, values := range cer.Nodes {
 		if len(values) > 0 {
@@ -199,42 +55,24 @@ func stateHandler(httpMethod string, cer *components.Cervice, sys *components.Sy
 		}
 	}
 
-	req, err := http.NewRequest(httpMethod, serviceUrl, bytes.NewReader(bodyBytes))
-	if err != nil {
-		return f, err
-	}
-
-	if httpMethod == "PUT" {
-		req.Header.Set("Content-Type", "application/json")
-	}
-
-	req = req.WithContext(ctx)
-
-	resp, err := http.DefaultClient.Do(req)
+	resp, err := sendHttpReq(httpMethod, serviceUrl, bodyBytes)
 	if err != nil {
-		cer.Nodes = make(map[string][]string)
+		cer.Nodes = make(map[string][]string) // Failed to get the resource at that location: reset the providers list, which will trigger a new service search
 		return f, err
 	}
 	defer resp.Body.Close()
 
-	// Check if the status code indicates an error (anything outside the 200–299 range)
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return f, fmt.Errorf("received non-2xx status code: %d, response: %s", resp.StatusCode, http.StatusText(resp.StatusCode))
-	}
-
 	// If the response includes a payload, unpack it into a forms.Form
 	bodyBytes, err = io.ReadAll(resp.Body)
 	if err != nil {
-		return f, fmt.Errorf("error reading response body: %w", err)
+		return f, fmt.Errorf("reading state response body: %w", err)
 	}
 
-	if len(bodyBytes) > 0 {
-		headerContentType := resp.Header.Get("Content-Type")
-		f, err = Unpack(bodyBytes, headerContentType)
-		if err != nil {
-			return f, fmt.Errorf("error unpacking the service response: %w", err)
-		}
+	if len(bodyBytes) < 1 {
+		return f, fmt.Errorf("got empty response body: %w", err)
+
 	}
 
-	return f, nil
+	headerContentType := resp.Header.Get("Content-Type")
+	return Unpack(bodyBytes, headerContentType)
 }
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index 0b8a153..072f5f2 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -1,18 +1,14 @@
 package usecases
 
 import (
-	//"encoding/json"
-	//"fmt"
-	//"io"
-	//"reflect"
-	//"strings"
+	"encoding/json"
+	"errors"
 	"io"
+	"log"
 	"net/http"
 	"strings"
 	"testing"
 
-	//"time"
-
 	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
 )
@@ -39,19 +35,11 @@ func newTestCerviceWithNodes() *components.Cervice {
 	}
 }
 
-var testCerviceWithNodesRefresh = components.Cervice{
-	IReferentce: "test",
-	Definition:  "A test Cervice with nodes",
-	Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
-	Nodes:       map[string][]string{"test": {"https://testSystem/testUnitAsset/test"}},
-	Protos:      []string{"http"},
-}
-
 var testCerviceWithoutNodes = components.Cervice{
 	IReferentce: "test",
 	Definition:  "A test Cervice without nodes",
 	Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
-	Nodes:       nil,
+	Nodes:       make(map[string][]string),
 	Protos:      []string{"http"},
 }
 
@@ -67,74 +55,142 @@ var testSys = createTestSystem(false)
 
 var form forms.SignalA_v1a
 
-var testStateParams = []stateParams{
-	{
-		"No errors",
-		newTestCerviceWithNodes(),
-		&testSys,
-		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
-		func() *http.Response {
+var errEmptyRespBody = errors.New("got empty response body")
+
+var errUnpack = errors.New("Problem unpacking response body")
+
+func createTestBytes() []byte {
+	return []byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}")
+}
+
+func createWorkingHttpResp() func() *http.Response {
+	httpResp := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+		}
+	}
+	return httpResp
+}
+
+// This function creates two different http responses with a different body, since some tests build on receiving multiple correct http responses
+func createDoubleHttpResp() func() *http.Response {
+	f := createServicePointTestForm()
+	// Create mock response from orchestrator
+	fakeBody, err := json.Marshal(f)
+	if err != nil {
+		log.Println("Fail Marshal at start of test")
+	}
+	count := 0
+	return func() *http.Response {
+		count++
+		if count == 2 || count == 5 {
 			return &http.Response{
 				Status:     "200 OK",
 				StatusCode: 200,
 				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+				Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
 			}
-		},
+		}
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+		}
+	}
+}
+
+func createEmptyHttpResp() func() *http.Response {
+	httpResp := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(""))),
+		}
+	}
+	return httpResp
+}
+
+func createStatusErrorHttpResp() func() *http.Response {
+	httpResp := func() *http.Response {
+		return &http.Response{
+			Status:     "300 NAK",
+			StatusCode: 300,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+		}
+	}
+	return httpResp
+}
+
+func createErrorReaderHttpResp() func() *http.Response {
+	httpResp := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(errorReader{}),
+		}
+	}
+	return httpResp
+}
+
+func createUnpackErrorHttpResp() func() *http.Response {
+	httpResp := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"Wrong content type"}},
+			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+		}
+	}
+	return httpResp
+}
+
+var testStateParams = []stateParams{
+	{
+		"No errors with nodes",
+		newTestCerviceWithNodes(),
+		&testSys,
+		createTestBytes(),
+		createWorkingHttpResp(),
 		0,
 		nil,
 		form.NewForm(),
 		nil,
 	},
 	{
-		"No errors",
+		"No errors without nodes",
 		&testCerviceWithoutNodes,
 		&testSys,
-		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
-			}
-		},
+		createTestBytes(),
+		createDoubleHttpResp(),
 		0,
 		nil,
 		form.NewForm(),
 		nil,
 	},
 	{
-		"No errors SetState",
+		"Empty response body error",
 		newTestCerviceWithNodes(),
 		&testSys,
 		nil,
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string(""))),
-			}
-		},
+		createEmptyHttpResp(),
 		0,
 		nil,
-		form.NewForm(),
 		nil,
+		errEmptyRespBody,
 	},
 	{
 		"Search4Services error",
 		&testCerviceWithoutNodes,
 		&testSys,
-		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
-			}
-		},
+		createTestBytes(),
+		createWorkingHttpResp(),
 		1,
 		errHTTP,
 		nil,
@@ -144,16 +200,9 @@ var testStateParams = []stateParams{
 		"NewRequest() error",
 		&testCerviceWithBrokenUrl,
 		&testSys,
-		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
-			}
-		},
-		1,
+		createTestBytes(),
+		createWorkingHttpResp(),
+		2,
 		errHTTP,
 		nil,
 		errHTTP,
@@ -162,15 +211,8 @@ var testStateParams = []stateParams{
 		"Status code error",
 		newTestCerviceWithNodes(),
 		&testSys,
-		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
-		func() *http.Response {
-			return &http.Response{
-				Status:     "300 NAK",
-				StatusCode: 300,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
-			}
-		},
+		createTestBytes(),
+		createStatusErrorHttpResp(),
 		2,
 		errHTTP,
 		nil,
@@ -180,51 +222,30 @@ var testStateParams = []stateParams{
 		"io.ReadAll() error",
 		newTestCerviceWithNodes(),
 		&testSys,
-		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(errorReader{}),
-			}
-		},
+		createTestBytes(),
+		createErrorReaderHttpResp(),
 		0,
 		nil,
 		nil,
-		nil,
+		errBodyRead,
 	},
 	{
 		"Unpack() error",
 		newTestCerviceWithNodes(),
 		&testSys,
-		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"Wrong content type"}},
-				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
-			}
-		},
+		createTestBytes(),
+		createUnpackErrorHttpResp(),
 		0,
 		nil,
 		nil,
-		nil,
+		errUnpack,
 	},
 	{
 		"DefaultClient.Do() error",
 		newTestCerviceWithNodes(),
 		&testSys,
-		[]byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"),
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
-			}
-		},
+		createTestBytes(),
+		createWorkingHttpResp(),
 		1,
 		errHTTP,
 		nil,
@@ -235,27 +256,16 @@ var testStateParams = []stateParams{
 func TestGetState(t *testing.T) {
 	for _, test := range testStateParams {
 		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
-
-		// No need to test this as the test is specifically for SetState
-		if test.testCase == "No errors SetState" {
-			continue
-		}
-
 		res, err := GetState(test.testCer, test.testSys)
 
-		// Directly compare the fields of the expected and actual forms
-		if res != nil && test.bodyBytes != nil {
+		if test.expectedfForm != nil {
 			expected := test.expectedfForm.(*forms.SignalA_v1a)
 			actual := res.(*forms.SignalA_v1a)
-			if test.testCase == "No errors" {
-				if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
-					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
-				}
-			}
-		} else {
-			if err == nil {
-				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
+			if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
+				t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
 			}
+		} else if err == nil {
+			t.Errorf("Test case: %s got error: %v:", test.testCase, err)
 		}
 	}
 }
@@ -265,84 +275,21 @@ func TestSetState(t *testing.T) {
 		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
 
 		if test.testCase == "DefaultClient.Do() error" {
-			test.testCer = &testCerviceWithNodesRefresh
-		}
-		res, err := SetState(test.testCer, test.testSys, nil)
-
-		// Directly compare the fields of the expected and actual forms
-		if res != nil && test.bodyBytes != nil {
-			expected := test.expectedfForm.(*forms.SignalA_v1a)
-			actual := res.(*forms.SignalA_v1a)
-			if test.testCase == "No errors" {
-				if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
-					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
-				}
-			}
-		} else if test.bodyBytes == nil {
-			if err != nil && res != nil {
-				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
-			}
-		} else {
-			if err == nil {
-				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
-			}
-		}
-	}
-}
-
-/*
-func TestForstateHandler(t *testing.T) {
-	for _, test := range testStateParams {
-		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
-
-		// No need to test this as the test is specifically for SetState
-		if test.testCase == "No errors SetState" {
-			continue
+			test.testCer.Nodes = map[string][]string{"test": {"https://testSystem/testUnitAsset/test"}}
 		}
-
-		res, err := GetState(test.testCer, test.testSys)
-
-		// Directly compare the fields of the expected and actual forms
-		if res != nil && test.bodyBytes != nil {
-			expected := test.expectedfForm.(*forms.SignalA_v1a)
-			actual := res.(*forms.SignalA_v1a)
-			if test.testCase == "No errors" {
-				if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
-					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
-				}
-			}
-		} else {
-			if err == nil {
-				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
-			}
-		}
-	}
-	for _, test := range testStateParams {
-		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
-
-		if test.testCase == "DefaultClient.Do() error" {
-			test.testCer = &testCerviceWithNodesRefresh
+		if test.testCase == "No errors without nodes" {
+			test.testCer.Nodes = make(map[string][]string)
 		}
 		res, err := SetState(test.testCer, test.testSys, test.bodyBytes)
 
-		// Directly compare the fields of the expected and actual forms
-		if res != nil && test.bodyBytes != nil {
+		if test.expectedfForm != nil {
 			expected := test.expectedfForm.(*forms.SignalA_v1a)
 			actual := res.(*forms.SignalA_v1a)
-			if test.testCase == "No errors" {
-				if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
-					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
-				}
-			}
-		} else if test.bodyBytes == nil {
-			if err != nil && res != nil {
-				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
-			}
-		} else {
-			if err == nil {
-				t.Errorf("Test case: %s got error: %v:", test.testCase, err)
+			if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
+				t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
 			}
+		} else if err == nil {
+			t.Errorf("Test case: %s got error: %v:", test.testCase, err)
 		}
 	}
 }
-*/

From 7eb96d970c4711a103f62cf29601e750dfae36aa Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 23 Jun 2025 15:58:41 +0200
Subject: [PATCH 058/186] Fixed table driven test to be more readable

---
 usecases/consumption_test.go | 110 ++++-------------------------------
 1 file changed, 10 insertions(+), 100 deletions(-)

diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index 072f5f2..0af440c 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -14,7 +14,6 @@ import (
 )
 
 type stateParams struct {
-	testCase         string
 	testCer          *components.Cervice
 	testSys          *components.System
 	bodyBytes        []byte
@@ -23,6 +22,7 @@ type stateParams struct {
 	errHTTP          error
 	expectedfForm    forms.Form
 	expectedErr      error
+	testCase         string
 }
 
 func newTestCerviceWithNodes() *components.Cervice {
@@ -152,105 +152,15 @@ func createUnpackErrorHttpResp() func() *http.Response {
 }
 
 var testStateParams = []stateParams{
-	{
-		"No errors with nodes",
-		newTestCerviceWithNodes(),
-		&testSys,
-		createTestBytes(),
-		createWorkingHttpResp(),
-		0,
-		nil,
-		form.NewForm(),
-		nil,
-	},
-	{
-		"No errors without nodes",
-		&testCerviceWithoutNodes,
-		&testSys,
-		createTestBytes(),
-		createDoubleHttpResp(),
-		0,
-		nil,
-		form.NewForm(),
-		nil,
-	},
-	{
-		"Empty response body error",
-		newTestCerviceWithNodes(),
-		&testSys,
-		nil,
-		createEmptyHttpResp(),
-		0,
-		nil,
-		nil,
-		errEmptyRespBody,
-	},
-	{
-		"Search4Services error",
-		&testCerviceWithoutNodes,
-		&testSys,
-		createTestBytes(),
-		createWorkingHttpResp(),
-		1,
-		errHTTP,
-		nil,
-		errHTTP,
-	},
-	{
-		"NewRequest() error",
-		&testCerviceWithBrokenUrl,
-		&testSys,
-		createTestBytes(),
-		createWorkingHttpResp(),
-		2,
-		errHTTP,
-		nil,
-		errHTTP,
-	},
-	{
-		"Status code error",
-		newTestCerviceWithNodes(),
-		&testSys,
-		createTestBytes(),
-		createStatusErrorHttpResp(),
-		2,
-		errHTTP,
-		nil,
-		errHTTP,
-	},
-	{
-		"io.ReadAll() error",
-		newTestCerviceWithNodes(),
-		&testSys,
-		createTestBytes(),
-		createErrorReaderHttpResp(),
-		0,
-		nil,
-		nil,
-		errBodyRead,
-	},
-	{
-		"Unpack() error",
-		newTestCerviceWithNodes(),
-		&testSys,
-		createTestBytes(),
-		createUnpackErrorHttpResp(),
-		0,
-		nil,
-		nil,
-		errUnpack,
-	},
-	{
-		"DefaultClient.Do() error",
-		newTestCerviceWithNodes(),
-		&testSys,
-		createTestBytes(),
-		createWorkingHttpResp(),
-		1,
-		errHTTP,
-		nil,
-		errHTTP,
-	},
+	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createWorkingHttpResp(), 0, nil, form.NewForm(), nil, "No errors with nodes"},
+	{&testCerviceWithoutNodes, &testSys, createTestBytes(), createDoubleHttpResp(), 0, nil, form.NewForm(), nil, "No errors without nodes"},
+	{newTestCerviceWithNodes(), &testSys, nil, createEmptyHttpResp(), 0, nil, nil, errEmptyRespBody, "Empty response body error"},
+	{&testCerviceWithoutNodes, &testSys, createTestBytes(), createWorkingHttpResp(), 1, errHTTP, nil, errHTTP, "Search4Services error"},
+	{&testCerviceWithBrokenUrl, &testSys, createTestBytes(), createWorkingHttpResp(), 2, errHTTP, nil, errHTTP, "NewRequest() error"},
+	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createStatusErrorHttpResp(), 2, errHTTP, nil, errHTTP, "Status code error"},
+	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createErrorReaderHttpResp(), 0, nil, nil, errBodyRead, "io.ReadAll() error"},
+	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createUnpackErrorHttpResp(), 0, nil, nil, errUnpack, "Unpack() error"},
+	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createWorkingHttpResp(), 1, errHTTP, nil, errHTTP, "DefaultClient.Do() error"},
 }
 
 func TestGetState(t *testing.T) {

From 5ae22306d1d94d701267d38e6e6cb789bf9b90eb Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Mon, 23 Jun 2025 08:29:30 +0200
Subject: [PATCH 059/186] Renames all files to have consistent names
 (snake_case)

---
 forms/{certificateForms.go => certificate_forms.go}              | 0
 forms/{costForms.go => cost_forms.go}                            | 0
 forms/{fileForms.go => file_forms.go}                            | 0
 forms/{formsDefinition.go => forms_definition.go}                | 0
 forms/{serviceForms.go => service_forms.go}                      | 0
 forms/{servicequestForms.go => servicequest_forms.go}            | 0
 forms/{signalForms.go => signal_forms.go}                        | 0
 forms/{systemForms.go => system_forms.go}                        | 0
 usecases/{serversNhandlers.go => servers_handlers.go}            | 0
 usecases/{serviceDiscovery.go => service_discovery.go}           | 0
 usecases/{serviceDiscovery_test.go => service_discovery_test.go} | 0
 11 files changed, 0 insertions(+), 0 deletions(-)
 rename forms/{certificateForms.go => certificate_forms.go} (100%)
 rename forms/{costForms.go => cost_forms.go} (100%)
 rename forms/{fileForms.go => file_forms.go} (100%)
 rename forms/{formsDefinition.go => forms_definition.go} (100%)
 rename forms/{serviceForms.go => service_forms.go} (100%)
 rename forms/{servicequestForms.go => servicequest_forms.go} (100%)
 rename forms/{signalForms.go => signal_forms.go} (100%)
 rename forms/{systemForms.go => system_forms.go} (100%)
 rename usecases/{serversNhandlers.go => servers_handlers.go} (100%)
 rename usecases/{serviceDiscovery.go => service_discovery.go} (100%)
 rename usecases/{serviceDiscovery_test.go => service_discovery_test.go} (100%)

diff --git a/forms/certificateForms.go b/forms/certificate_forms.go
similarity index 100%
rename from forms/certificateForms.go
rename to forms/certificate_forms.go
diff --git a/forms/costForms.go b/forms/cost_forms.go
similarity index 100%
rename from forms/costForms.go
rename to forms/cost_forms.go
diff --git a/forms/fileForms.go b/forms/file_forms.go
similarity index 100%
rename from forms/fileForms.go
rename to forms/file_forms.go
diff --git a/forms/formsDefinition.go b/forms/forms_definition.go
similarity index 100%
rename from forms/formsDefinition.go
rename to forms/forms_definition.go
diff --git a/forms/serviceForms.go b/forms/service_forms.go
similarity index 100%
rename from forms/serviceForms.go
rename to forms/service_forms.go
diff --git a/forms/servicequestForms.go b/forms/servicequest_forms.go
similarity index 100%
rename from forms/servicequestForms.go
rename to forms/servicequest_forms.go
diff --git a/forms/signalForms.go b/forms/signal_forms.go
similarity index 100%
rename from forms/signalForms.go
rename to forms/signal_forms.go
diff --git a/forms/systemForms.go b/forms/system_forms.go
similarity index 100%
rename from forms/systemForms.go
rename to forms/system_forms.go
diff --git a/usecases/serversNhandlers.go b/usecases/servers_handlers.go
similarity index 100%
rename from usecases/serversNhandlers.go
rename to usecases/servers_handlers.go
diff --git a/usecases/serviceDiscovery.go b/usecases/service_discovery.go
similarity index 100%
rename from usecases/serviceDiscovery.go
rename to usecases/service_discovery.go
diff --git a/usecases/serviceDiscovery_test.go b/usecases/service_discovery_test.go
similarity index 100%
rename from usecases/serviceDiscovery_test.go
rename to usecases/service_discovery_test.go

From 6624d491cb3664bb9aaf766042e320c3f4b812ae Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 22 Jun 2025 11:33:34 +0200
Subject: [PATCH 060/186] Adds tests for components/system

---
 components/system_test.go | 179 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 179 insertions(+)
 create mode 100644 components/system_test.go

diff --git a/components/system_test.go b/components/system_test.go
new file mode 100644
index 0000000..dd3c1b2
--- /dev/null
+++ b/components/system_test.go
@@ -0,0 +1,179 @@
+package components
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+func TestNewSystem(t *testing.T) {
+	name := "TestingSystem"
+	ctx, cancel := context.WithCancel(context.Background())
+	sys := NewSystem(name, ctx)
+
+	if sys.Name != name {
+		t.Errorf("expected system name %s, got %s", name, sys.Name)
+	}
+
+	// It's a bit of a silly test but the system context is an important dependency
+	// for cancelling some background services (system registration and http servers).
+	select {
+	case <-sys.Ctx.Done():
+		t.Fatal("expected context to NOT be cancelled")
+	default:
+		// pass
+	}
+
+	cancel()
+	select {
+	case <-sys.Ctx.Done():
+		// pass
+	default:
+		t.Error("expected context to be cancelled")
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+type errorReadCloser struct {
+	r        io.Reader
+	errRead  error
+	errClose error
+}
+
+func (ec errorReadCloser) Read(p []byte) (n int, err error) {
+	if ec.errRead != nil {
+		return 0, ec.errRead
+	}
+	return ec.r.Read(p)
+}
+
+func (ec errorReadCloser) Close() error {
+	return ec.errClose
+}
+
+var errMockTrans = fmt.Errorf("mock error")
+
+type mockTrans struct {
+	status       int
+	body         string
+	err          error
+	errBody      error
+	errBodyClose error
+}
+
+func newMockTransport() *mockTrans {
+	t := &mockTrans{
+		status: http.StatusOK,
+	}
+	// Hijack the default http client so no actual http requests are sent over the network
+	http.DefaultClient.Transport = t
+	return t
+}
+
+func (t *mockTrans) setResponse(status int, body string) {
+	t.status = status
+	t.body = body
+}
+
+func (t *mockTrans) setError() {
+	t.err = errMockTrans
+}
+
+func (t *mockTrans) setBodyError() {
+	t.errBody = errMockTrans
+}
+
+func (t *mockTrans) setBodyCloseError() {
+	t.errBodyClose = errMockTrans
+}
+
+// RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
+// It prevents the request from being sent over the network.
+func (t *mockTrans) RoundTrip(req *http.Request) (*http.Response, error) {
+	if t.err != nil {
+		return nil, t.err
+	}
+	resp := &http.Response{
+		StatusCode: t.status,
+		Status:     http.StatusText(t.status),
+		Body: errorReadCloser{
+			strings.NewReader(t.body),
+			t.errBody,
+			t.errBodyClose,
+		},
+		ContentLength: int64(len(t.body)),
+		Request:       req,
+	}
+	return resp, nil
+}
+
+const leadRegPrefix = "lead Service Registrar since"
+const coreRegURL = "http://registrar"
+
+var coreReg = &CoreSystem{"serviceregistrar", coreRegURL}
+var coreFake = &CoreSystem{"fakesystem", "http://fake"}
+
+type sampleGetRunningCoreSystem struct {
+	name    string
+	url     string
+	wantErr bool
+	setup   func(*mockTrans)
+}
+
+var tableGetRunningCoreSystem = []sampleGetRunningCoreSystem{
+	// Case: return url for registrar
+	{coreReg.Name, coreReg.Url, false, func(m *mockTrans) { m.setResponse(200, leadRegPrefix) }},
+	// Case: return url.Parse() error for registrar
+	{coreReg.Name, "", true, func(m *mockTrans) { coreReg.Url = string(rune(0)) }},
+	// Case: return http.Get() error fro registrar
+	{coreReg.Name, "", true, func(m *mockTrans) { m.setError() }},
+	// Case: return io.ReadAll() error for registrar
+	{coreReg.Name, "", true, func(m *mockTrans) { m.setBodyError() }},
+	// Case: return body.Close() error for registrar
+	{coreReg.Name, "", true, func(m *mockTrans) { m.setBodyCloseError() }},
+	// Case: return error when missing prefix string in body for registrar
+	{coreReg.Name, "", true, nil},
+
+	// Case: return url and no error for non-registrar
+	{coreFake.Name, coreFake.Url, false, nil},
+	// Case: return http.Get() error for non-registrar
+	{coreFake.Name, "", true, func(m *mockTrans) { m.setError() }},
+	// Case: return body.Close() error for non-registrar
+	// TODO: can't test this for now, since the original error handling is so poor
+	// {coreFake.Name, "", true, func(m *mockTrans) { m.setBodyCloseError() }},
+}
+
+func TestGetRunningCoreSystem(t *testing.T) {
+	name := "testSystem"
+	sys := NewSystem(name, context.Background())
+
+	// Case: return error for empty core system list (and should not match itself)
+	if len(sys.CoreS) != 0 {
+		t.Fatalf("expected no core systems, had %d in list", len(sys.CoreS))
+	}
+	_, err := GetRunningCoreSystemURL(&sys, name)
+	if err == nil {
+		t.Error("expected error, got nil")
+	}
+	sys.CoreS = []*CoreSystem{coreReg, coreFake}
+
+	for _, test := range tableGetRunningCoreSystem {
+		coreReg.Url = coreRegURL // reset after testing url.Parse errors
+		m := newMockTransport()
+		if test.setup != nil {
+			test.setup(m)
+		}
+
+		gotURL, gotErr := GetRunningCoreSystemURL(&sys, test.name)
+		switch {
+		case test.wantErr == (gotErr == nil):
+			t.Errorf("expected error = %v, got '%v'", test.wantErr, gotErr)
+		case gotURL != test.url:
+			t.Errorf("expected core system URL '%s', got '%s'", test.url, gotURL)
+		}
+	}
+}

From cc2b752abca1ffa4dc209a24f935e6c10d0d885d Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 22 Jun 2025 11:33:34 +0200
Subject: [PATCH 061/186] Refactors GetRunningCoreSystemURL

Improvements:
- Increases readability
- Adds helper constants for magic strings
- Doesn't print errors to the console!
---
 components/system.go      | 99 ++++++++++++++++++++++-----------------
 components/system_test.go | 52 ++++++++++++--------
 2 files changed, 88 insertions(+), 63 deletions(-)

diff --git a/components/system.go b/components/system.go
index 026a87c..17db971 100644
--- a/components/system.go
+++ b/components/system.go
@@ -22,6 +22,7 @@
 package components
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"io"
@@ -29,7 +30,6 @@ import (
 	"net/url"
 	"os"
 	"os/signal"
-	"strings"
 	"syscall"
 )
 
@@ -64,57 +64,70 @@ func NewSystem(name string, ctx context.Context) System {
 	return newSystem
 }
 
+func verifyStatus(u *url.URL) ([]byte, error) {
+	resp, err := http.Get(u.String())
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	// Body must be fully drained AND closed upon returning, otherwise it might leak memory
+	body, err := io.ReadAll(resp.Body)
+	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		return nil, fmt.Errorf("bad response: %d %s", resp.StatusCode, resp.Status)
+	}
+	return body, err
+}
+
+const ServiceRegistrarName string = "serviceregistrar"
+const ServiceRegistrarLeader string = "lead Service Registrar since"
+
 // GetRunningCoreSystemURL returns the URL of a running core system based on the provided type.
 // When systemType is "serviceregistrar", it verifies the service is the lead registrar by checking
 // its /status endpoint response. For other core system types, it simply tests that the URL is accessible.
 func GetRunningCoreSystemURL(sys *System, systemType string) (string, error) {
+	// Store the latest error encountered when iterating thru the system list
+	// and then return this error if no matching system was found.
+	var lastErr error
+
 	for _, core := range sys.CoreS {
-		if core.Name == systemType {
-			// Special logic for the service registrar: check the status endpoint
-			if systemType == "serviceregistrar" {
-				// statusURL := core.Url + "/status"
-				statusURL, err := url.Parse(core.Url + "/status")
-				if err != nil {
-					fmt.Printf("error parsing core URL for the service registrar: %s\n", err)
-					continue
-				}
-				resp, err := http.Get(statusURL.String())
-				if err != nil {
-					fmt.Printf("error checking service registrar status at %s: %v\n", statusURL, err)
-					continue // Try the next core system instance, if any.
-				}
-				bodyBytes, err := io.ReadAll(resp.Body)
-				errClose := resp.Body.Close() // Always close the response body when done.
-				if err != nil {
-					fmt.Printf("error reading response from %s: %v\n", statusURL, err)
-					continue
-				}
-				if errClose != nil {
-					fmt.Printf("error closing response body: %s\n", errClose)
-				}
-				// Verify status response
-				if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
-					fmt.Printf("Lead service registrar found at: %s\n", core.Url)
-					return core.Url, nil
-				}
-			} else {
-				// For other core systems, verify that the service is accessible.
-				resp, err := http.Get(core.Url)
-				if err != nil {
-					fmt.Printf("error checking %s at %s: %v\n", systemType, core.Url, err)
-					continue
-				}
-				if err = resp.Body.Close(); err != nil {
-					fmt.Printf("error while closing response body: %s\n", err)
-				}
-				return core.Url, nil
-			}
+		// Ignore unrelated systems
+		if core.Name != systemType {
+			continue
+		}
+
+		coreURL, err := url.Parse(core.Url)
+		if err != nil {
+			lastErr = fmt.Errorf("parsing core URL: %w", err)
+			continue
 		}
+		if systemType == ServiceRegistrarName {
+			coreURL = coreURL.JoinPath("status")
+		}
+
+		body, err := verifyStatus(coreURL)
+		if err != nil {
+			lastErr = fmt.Errorf("verifying core URL: %w", err)
+			continue
+		}
+
+		// Skips non-leading registrars
+		// TODO: race condition when the lead drops and no other registrar have
+		// picked up the slack yet? - Alex
+		if systemType == ServiceRegistrarName && !bytes.HasPrefix(body, []byte(ServiceRegistrarLeader)) {
+			continue
+		}
+
+		return coreURL.String(), nil
+	}
+
+	err := fmt.Errorf("core system '%s' not found", systemType)
+	if lastErr != nil {
+		err = fmt.Errorf("core system '%s' not found: %w", systemType, lastErr)
 	}
-	return "", fmt.Errorf("failed to locate running core system of type %s", systemType)
+	return "", err
 }
 
-// The following code is used only for issues support on GitHub @sdoque --------------------------
+// The following code is used only for issues support on GitHub @sdoque
 var (
 	AppName   string
 	Version   string
diff --git a/components/system_test.go b/components/system_test.go
index dd3c1b2..159b1e1 100644
--- a/components/system_test.go
+++ b/components/system_test.go
@@ -111,11 +111,11 @@ func (t *mockTrans) RoundTrip(req *http.Request) (*http.Response, error) {
 	return resp, nil
 }
 
-const leadRegPrefix = "lead Service Registrar since"
 const coreRegURL = "http://registrar"
+const coreFakeURL = "http://fake"
 
-var coreReg = &CoreSystem{"serviceregistrar", coreRegURL}
-var coreFake = &CoreSystem{"fakesystem", "http://fake"}
+var coreReg = &CoreSystem{ServiceRegistrarName, coreRegURL}
+var coreFake = &CoreSystem{"fakesystem", coreFakeURL}
 
 type sampleGetRunningCoreSystem struct {
 	name    string
@@ -125,26 +125,37 @@ type sampleGetRunningCoreSystem struct {
 }
 
 var tableGetRunningCoreSystem = []sampleGetRunningCoreSystem{
-	// Case: return url for registrar
-	{coreReg.Name, coreReg.Url, false, func(m *mockTrans) { m.setResponse(200, leadRegPrefix) }},
-	// Case: return url.Parse() error for registrar
+	// Tests for non-registrars
+	// Case: url.Parse() error
+	{coreFake.Name, "", true, func(m *mockTrans) { coreFake.Url = string(rune(0)) }},
+	// Case: http.Get() error
+	{coreFake.Name, "", true, func(m *mockTrans) { m.setError() }},
+	// Case: io.ReadAll() error
+	{coreFake.Name, "", true, func(m *mockTrans) { m.setBodyError() }},
+	// Case: http < 200 error
+	{coreFake.Name, "", true, func(m *mockTrans) { m.setResponse(199, "") }},
+	// Case: http > 299 error
+	{coreFake.Name, "", true, func(m *mockTrans) { m.setResponse(300, "") }},
+	// Case: return url
+	{coreFake.Name, coreFake.Url, false, nil},
+
+	// Tests for registrars
+	// Case: url.Parse() error
 	{coreReg.Name, "", true, func(m *mockTrans) { coreReg.Url = string(rune(0)) }},
-	// Case: return http.Get() error fro registrar
+	// Case: http.Get() error
 	{coreReg.Name, "", true, func(m *mockTrans) { m.setError() }},
-	// Case: return io.ReadAll() error for registrar
+	// Case: io.ReadAll() error
 	{coreReg.Name, "", true, func(m *mockTrans) { m.setBodyError() }},
-	// Case: return body.Close() error for registrar
-	{coreReg.Name, "", true, func(m *mockTrans) { m.setBodyCloseError() }},
+	// Case: http < 200 error
+	{coreReg.Name, "", true, func(m *mockTrans) { m.setResponse(199, "") }},
+	// Case: http > 299 error
+	{coreReg.Name, "", true, func(m *mockTrans) { m.setResponse(300, "") }},
 	// Case: return error when missing prefix string in body for registrar
 	{coreReg.Name, "", true, nil},
-
-	// Case: return url and no error for non-registrar
-	{coreFake.Name, coreFake.Url, false, nil},
-	// Case: return http.Get() error for non-registrar
-	{coreFake.Name, "", true, func(m *mockTrans) { m.setError() }},
-	// Case: return body.Close() error for non-registrar
-	// TODO: can't test this for now, since the original error handling is so poor
-	// {coreFake.Name, "", true, func(m *mockTrans) { m.setBodyCloseError() }},
+	// Case: return url
+	{coreReg.Name, coreReg.Url + "/status", false, func(m *mockTrans) {
+		m.setResponse(200, ServiceRegistrarLeader)
+	}},
 }
 
 func TestGetRunningCoreSystem(t *testing.T) {
@@ -162,7 +173,8 @@ func TestGetRunningCoreSystem(t *testing.T) {
 	sys.CoreS = []*CoreSystem{coreReg, coreFake}
 
 	for _, test := range tableGetRunningCoreSystem {
-		coreReg.Url = coreRegURL // reset after testing url.Parse errors
+		coreReg.Url = coreRegURL // reset URLs after testing url.Parse() errors
+		coreFake.Url = coreFakeURL
 		m := newMockTransport()
 		if test.setup != nil {
 			test.setup(m)
@@ -171,7 +183,7 @@ func TestGetRunningCoreSystem(t *testing.T) {
 		gotURL, gotErr := GetRunningCoreSystemURL(&sys, test.name)
 		switch {
 		case test.wantErr == (gotErr == nil):
-			t.Errorf("expected error = %v, got '%v'", test.wantErr, gotErr)
+			t.Errorf("expected error = %v, got: %v", test.wantErr, gotErr)
 		case gotURL != test.url:
 			t.Errorf("expected core system URL '%s', got '%s'", test.url, gotURL)
 		}

From 73e7edf8c85ce45c4cf6b47d452c83e2ad0957d0 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 22 Jun 2025 17:27:13 +0200
Subject: [PATCH 062/186] Lets usecases/authentication use new get core func

---
 usecases/authentication.go | 28 +++-------------------------
 1 file changed, 3 insertions(+), 25 deletions(-)

diff --git a/usecases/authentication.go b/usecases/authentication.go
index 0daec0e..8514f32 100644
--- a/usecases/authentication.go
+++ b/usecases/authentication.go
@@ -126,16 +126,9 @@ func RequestCertificate(sys *components.System) {
 }
 
 func sendCSR(sys *components.System, csrPEM []byte) (string, error) {
-	var err error
-	url := ""
-	for _, cSys := range sys.CoreS {
-		core := cSys
-		if core.Name == "ca" {
-			url = core.Url
-		}
-	}
-	if url == "" {
-		return "", fmt.Errorf("failed to locate certificate authority: %w", err)
+	url, err := components.GetRunningCoreSystemURL(sys, "ca") // Assuming the first core system is the CA
+	if err != nil {
+		return "", fmt.Errorf("failed to get CA URL: %w", err)
 	}
 	url += "/certify"
 
@@ -163,19 +156,6 @@ func sendCSR(sys *components.System, csrPEM []byte) (string, error) {
 
 // getCACertificate gets the CA's certificate necessary for the dual server-client authentication in the TLS setup
 func getCACertificate(sys *components.System) (string, error) {
-	// var err error
-	// coreUAurl := ""
-	// for _, cSys := range sys.CoreS {
-	// 	core := cSys
-	// 	if core.Name == "ca" {
-	// 		coreUAurl = core.Url
-	// 	}
-	// }
-	// if coreUAurl == "" {
-	// 	return "", fmt.Errorf("failed to locate certificate authority: %w", err)
-	// }
-
-	// Get the URL of the CA's configuration
 	coreUAurl, err := components.GetRunningCoreSystemURL(sys, "ca") // Assuming the first core system is the CA
 	if err != nil {
 		return "", fmt.Errorf("failed to get CA URL: %w", err)
@@ -184,8 +164,6 @@ func getCACertificate(sys *components.System) (string, error) {
 	url := strings.TrimSuffix(coreUAurl, "ification")
 
 	// Make a GET request to the CA's endpoint
-	// https://stackoverflow.com/questions/70281883/golang-untaint-url-variable-to-fix-gosec-warning-g107
-	//resp, err := http.Get(url)
 	req, err := http.NewRequest(http.MethodGet, url, nil)
 	if err != nil {
 		log.Printf("Error creating NewRequest: %v", err)

From e88eb536a1b191f6010a7828d112c957014df121 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 22 Jun 2025 17:41:57 +0200
Subject: [PATCH 063/186] Fixes returning preserved core URL

---
 components/system.go      | 3 ++-
 components/system_test.go | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/components/system.go b/components/system.go
index 17db971..4ee937f 100644
--- a/components/system.go
+++ b/components/system.go
@@ -100,6 +100,7 @@ func GetRunningCoreSystemURL(sys *System, systemType string) (string, error) {
 			lastErr = fmt.Errorf("parsing core URL: %w", err)
 			continue
 		}
+		coreSystemURL := coreURL.String() // Preserves the original URL
 		if systemType == ServiceRegistrarName {
 			coreURL = coreURL.JoinPath("status")
 		}
@@ -117,7 +118,7 @@ func GetRunningCoreSystemURL(sys *System, systemType string) (string, error) {
 			continue
 		}
 
-		return coreURL.String(), nil
+		return coreSystemURL, nil
 	}
 
 	err := fmt.Errorf("core system '%s' not found", systemType)
diff --git a/components/system_test.go b/components/system_test.go
index 159b1e1..dcf8f26 100644
--- a/components/system_test.go
+++ b/components/system_test.go
@@ -153,7 +153,7 @@ var tableGetRunningCoreSystem = []sampleGetRunningCoreSystem{
 	// Case: return error when missing prefix string in body for registrar
 	{coreReg.Name, "", true, nil},
 	// Case: return url
-	{coreReg.Name, coreReg.Url + "/status", false, func(m *mockTrans) {
+	{coreReg.Name, coreReg.Url, false, func(m *mockTrans) {
 		m.setResponse(200, ServiceRegistrarLeader)
 	}},
 }

From f5d70af94f387162d6069e668fae00ecdba76f91 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 22 Jun 2025 17:41:57 +0200
Subject: [PATCH 064/186] Refactors usecases/registration

Improvements:
- Removed lots of duplicate code and used get core func instead
- Cleaned up tests and made them more uniformed
- Removed dead code, spelling errors and other leftover cruft
---
 usecases/extra_utils_test.go  |   4 +-
 usecases/registration.go      | 106 ++++---------
 usecases/registration_test.go | 272 ++++------------------------------
 3 files changed, 60 insertions(+), 322 deletions(-)

diff --git a/usecases/extra_utils_test.go b/usecases/extra_utils_test.go
index b66e783..4b48685 100644
--- a/usecases/extra_utils_test.go
+++ b/usecases/extra_utils_test.go
@@ -80,7 +80,7 @@ func (errReader) Close() error {
 }
 
 // Variables used in testing
-var brokenUrl = string([]byte{0x7f})
+var brokenUrl = string(rune(0))
 var errHTTP error = fmt.Errorf("bad http request")
 
 // Help function to create a test system
@@ -132,7 +132,7 @@ func createTestSystem(broken bool) (sys components.System) {
 	sys.UAssets[mua.GetName()] = &muaInterface
 
 	leadingRegistrar := &components.CoreSystem{
-		Name: "serviceregistrar",
+		Name: components.ServiceRegistrarName,
 		Url:  "https://leadingregistrar",
 	}
 	test := &components.CoreSystem{
diff --git a/usecases/registration.go b/usecases/registration.go
index 774ec05..0cdeb9e 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -28,7 +28,6 @@ import (
 	"net"
 	"net/http"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/sdoque/mbaigo/components"
@@ -37,18 +36,17 @@ import (
 
 // RegisterServices keeps track of the leading Service Registrar and keeps all services registered
 func RegisterServices(sys *components.System) {
-	var leadingRegistrar *components.CoreSystem
+	var leadRegistrarURL string
 
 	// Goroutine looking for leading service registrar every 5 seconds
 	go func() {
 		ticker := time.NewTicker(5 * time.Second)
 		defer ticker.Stop()
 		for {
-			// Check if the leading registrar is already known
-			if leadingRegistrar != nil {
-				leadingRegistrar = confirmLeadingRegistrar(leadingRegistrar)
-			} else {
-				leadingRegistrar = findLeadingRegistrar(sys, leadingRegistrar)
+			var err error
+			leadRegistrarURL, err = components.GetRunningCoreSystemURL(sys, components.ServiceRegistrarName)
+			if err != nil {
+				log.Println("find lead registrar:", err)
 			}
 
 			select {
@@ -70,15 +68,11 @@ func RegisterServices(sys *components.System) {
 					timer := time.NewTimer(delay)
 					select {
 					case <-timer.C:
-						if leadingRegistrar != nil {
-							delay = registerService(sys, theUnitAsset, theService, leadingRegistrar)
-						} else {
-							delay = 15 * time.Second
-						}
+						delay = registerService(sys, leadRegistrarURL, theUnitAsset, theService)
 					case <-sys.Ctx.Done():
-						err := deregisterService(leadingRegistrar, theService)
+						err := unregisterService(leadRegistrarURL, theService)
 						if err != nil {
-							log.Println("deregistering service:", err)
+							log.Println("unregistering service:", err)
 						}
 						return
 					}
@@ -88,76 +82,32 @@ func RegisterServices(sys *components.System) {
 	}
 }
 
-func confirmLeadingRegistrar(leadingRegistrar *components.CoreSystem) *components.CoreSystem {
-	resp, err := http.Get(leadingRegistrar.Url + "/status")
-	if err != nil {
-		log.Println("lost leading registrar status:", err)
-		return nil
-	}
-	// Read from resp.Body and then close it directly after
-	bodyBytes, err := io.ReadAll(resp.Body)
-	defer resp.Body.Close() // Close the body directly after reading from it
-	if err != nil {
-		log.Println("\rError reading response from leading registrar:", err)
-		return nil
-	}
-	if !strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
-		log.Println("lost previous leading registrar")
-		return nil
-	}
-	return leadingRegistrar
-}
-
-func findLeadingRegistrar(sys *components.System, leadingRegistrar *components.CoreSystem) *components.CoreSystem {
-	for _, core := range sys.CoreS {
-		if core.Name != "serviceregistrar" {
-			continue
-		}
-
-		resp, err := http.Get(core.Url + "/status")
-		if err != nil {
-			log.Println("error checking service registrar status:", err)
-			continue // Skip to the next iteration of the loop
-		}
-
-		// Read from resp.Body and then close it directly after
-		bodyBytes, err := io.ReadAll(resp.Body)
-		defer resp.Body.Close() // Close the body directly after reading from it
-		if err != nil {
-			log.Println("Error reading service registrar response body:", err)
-			continue // Skip to the next iteration of the loop
-		}
-		if strings.HasPrefix(string(bodyBytes), "lead Service Registrar since") {
-			log.Printf("lead registrar found at: %s", core.Url)
-			return core
-		}
-	}
-	return leadingRegistrar
-}
-
 // registerService makes a POST or PUT request to register or register individual services
-func registerService(sys *components.System, ua *components.UnitAsset, serv *components.Service, registrar *components.CoreSystem) (delay time.Duration) {
-
+func registerService(sys *components.System, registrar string, ua *components.UnitAsset, serv *components.Service) (delay time.Duration) {
 	delay = 15 * time.Second
+	if registrar == "" {
+		return delay
+	}
+
 	// Prepare request
 	reqPayload, err := serviceRegistrationForm(sys, ua, serv, "ServiceRecord_v1")
 	if err != nil {
 		log.Println("Registration marshall error, ", err)
 		return
 	}
-	registrationurl := registrar.Url + "/register"
+	registrationURL := registrar + "/register"
 
 	var req *http.Request // Declare req outside the blocks
 	if serv.ID == 0 {
-		req, err = http.NewRequest("POST", registrationurl, bytes.NewBuffer(reqPayload))
+		req, err = http.NewRequest("POST", registrationURL, bytes.NewBuffer(reqPayload))
 		if err != nil {
 			log.Printf("unable to register service %s with lead registrar\n", serv.Definition)
 			return
 		}
 	} else {
-		req, err = http.NewRequest("PUT", registrationurl, bytes.NewBuffer(reqPayload))
+		req, err = http.NewRequest("PUT", registrationURL, bytes.NewBuffer(reqPayload))
 		if err != nil {
-			log.Printf("unable to confirm the %s service with lead registar", serv.Definition)
+			log.Printf("unable to confirm the %s service with lead registrar", serv.Definition)
 			return
 		}
 	}
@@ -168,14 +118,13 @@ func registerService(sys *components.System, ua *components.UnitAsset, serv *com
 		switch err := err.(type) {
 		case net.Error:
 			if err.Timeout() {
-				log.Printf("registry timeout with lead registrar %s\n", registrationurl)
+				log.Printf("registry timeout with lead registrar %s\n", registrationURL)
 			} else {
 				log.Printf("unable to (re-)register service %s with lead registrar\n", serv.Definition)
 			}
 		default:
-			log.Printf("registration request error with %s, and error %s\n", registrationurl, err)
+			log.Printf("registration request error with %s, and error %s\n", registrationURL, err)
 		}
-		registrar = nil
 		serv.ID = 0 // if re-registration failed, a complete new one should be made (POST)
 		return
 	}
@@ -190,8 +139,8 @@ func registerService(sys *components.System, ua *components.UnitAsset, serv *com
 			return
 		}
 
-		headerContentTtype := resp.Header.Get("Content-Type")
-		rRecord, err := Unpack(bodyBytes, headerContentTtype)
+		headerContentType := resp.Header.Get("Content-Type")
+		rRecord, err := Unpack(bodyBytes, headerContentType)
 		if err != nil {
 			log.Printf("error extracting the registration record reply %v\n", err)
 		}
@@ -211,18 +160,19 @@ func registerService(sys *components.System, ua *components.UnitAsset, serv *com
 			log.Printf("Error parsing input: %s", err)
 			return
 		}
-		delay = time.Until(parsedTime.Add(-5 * time.Second)) // should not wait until the deadline to start to confirrm live status
+		// should not wait until the deadline to start to confirm live status
+		delay = time.Until(parsedTime.Add(-5 * time.Second))
 	}
 	return
 }
 
-// deregisterService deletes a service from the database based on its service id
-func deregisterService(registrar *components.CoreSystem, serv *components.Service) error {
-	if registrar == nil {
+// unregisterService deletes a service from the database based on its service id
+func unregisterService(registrar string, serv *components.Service) error {
+	if registrar == "" {
 		return nil // there is no need to deregister if there is no leading registrar
 	}
-	deRegServURL := registrar.Url + "/unregister/" + strconv.Itoa(serv.ID)
-	req, err := http.NewRequest("DELETE", deRegServURL, nil) // create a new request using http
+	unregisterURL := registrar + "/unregister/" + strconv.Itoa(serv.ID)
+	req, err := http.NewRequest("DELETE", unregisterURL, nil) // create a new request using http
 	if err != nil {
 		return err
 	}
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 926c75f..894fd38 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
 )
 
@@ -26,222 +25,73 @@ func (errorReader) Read(p []byte) (int, error) {
 	return 0, fmt.Errorf("forced read error")
 }
 
-type tableDrivenParams struct {
-	testCase         string
-	body             func() *http.Response
-	mockTransportErr int
-	errHTTP          error
-	expectedOutput   *components.CoreSystem
-}
-
-var testParams = []tableDrivenParams{
-	{
-		"No errors",
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
-			}
-		},
-		0,
-		nil,
-		nil,
-	},
-	{
-		"Read error",
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(errorReader{}),
-			}
-		},
-		0,
-		nil,
-		nil,
-	},
-	{
-		"Prefix error",
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string("Wrong prefix"))),
-			}
-		},
-		0,
-		nil,
-		nil,
-	},
-	{
-		"Broken URL",
-		func() *http.Response {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string("lead Service Registrar since"))),
-			}
-		},
-		0,
-		nil,
-		nil,
-	},
-}
-
-func TestForconfirmLeadingRegistrar(t *testing.T) {
-	testSys := createTestSystem(false)
-
-	for _, test := range testParams {
-		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
-		if test.testCase == "Broken URL" {
-			testSys.CoreS[0].Url = brokenUrl
-		}
-
-		// Do the test
-		res := confirmLeadingRegistrar(testSys.CoreS[0])
-		if test.testCase == "No errors" {
-			test.expectedOutput = testSys.CoreS[0]
-			if res != test.expectedOutput {
-				t.Errorf("Test case: %s got error: %v", test.testCase, res)
-			}
-		} else {
-			if res != test.expectedOutput {
-				t.Errorf("---\tTest case: expected leading registrar to be nil, got: %v", res)
-			}
-		}
-	}
-}
-
-func TestForfindLeadingRegistrar(t *testing.T) {
-	testSys := createTestSystem(false)
-
-	for _, test := range testParams {
-		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
-		if test.testCase == "Broken URL" {
-			testSys.CoreS[0].Url = brokenUrl
-		}
-
-		// Do the test
-		res := findLeadingRegistrar(&testSys, nil)
-		if test.testCase == "No errors" {
-			test.expectedOutput = testSys.CoreS[0]
-			if res != test.expectedOutput {
-				t.Errorf("Test case: %s got error: %v", test.testCase, res)
-			}
-		} else {
-			if res != test.expectedOutput {
-				t.Errorf("---\tTest case: expected leading registrar to be nil, got: %v", res)
-			}
-		}
-	}
-}
-
-func TestFordeepCopyMap(t *testing.T) {
+func TestDeepCopyMap(t *testing.T) {
 	testSys := createTestSystem(false)
 	mua := testSys.UAssets["testUnitAsset"]
 	original := (*mua).GetDetails()
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Create a Deep Copy Map of the mockUnitAsset's Details
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	test := deepCopyMap((*mua).GetDetails())
-
-	// -- -- -- -- -- -- -- -- -- -- //
 	// If they are not equal from the beginning then the copy was not successful
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	if !reflect.DeepEqual(original, test) {
 		t.Errorf("Expected deep copied map to be equal to original, Expected: %v, got: %v", original, test)
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// When we change something in the original, the deep copied map should not change
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	original["Test"][0] = "changed original"
 	if reflect.DeepEqual(original, test) {
 		t.Errorf("Deep copy failed, changes in original affected the deep copied map. Expected: %v, got %v", original, test)
 	}
 	original["Test"][0] = "test"
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// When we change something in the deep copied map, the original should not change
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	test["Test"][0] = "changed deep copy"
 	if reflect.DeepEqual(original, test) {
 		t.Errorf("Deep copy failed, changes in deep copied map affected the original. Expected: %v, got %v", original, test)
 	}
 }
 
-func TestForserviceRegistrationForm(t *testing.T) {
+func TestServiceRegistrationForm(t *testing.T) {
 	testSys := createTestSystem(false)
 	mua := testSys.UAssets["testUnitAsset"]
 	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
 	version := "ServiceRecord_v1"
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Call the ServiceRegistrationForm with the correct parameters
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	payload, err := serviceRegistrationForm(&testSys, mua, serv, version)
-
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Check that there was no error in the function (can only be when wrong Service Record version is sent in)
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	if err != nil {
 		t.Fatalf("The Service Record version was wrong.")
 	}
-
 	var sr forms.ServiceRecord_v1
-	if err := json.Unmarshal(payload, &sr); err != nil {
+	if err = json.Unmarshal(payload, &sr); err != nil {
 		t.Fatalf("Invalid JSON: %v", err)
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Check that the ServiceNode is created correctly
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	expectedNode := testSys.Host.Name + "_" + testSys.Name + "_" + (*testSys.UAssets["testUnitAsset"]).GetName() + "_" + (*testSys.UAssets["testUnitAsset"]).GetServices()["test"].Definition
+	expectedNode := testSys.Host.Name + "_" + testSys.Name + "_" +
+		(*testSys.UAssets["testUnitAsset"]).GetName() + "_" +
+		(*testSys.UAssets["testUnitAsset"]).GetServices()["test"].Definition
 	if sr.ServiceNode != expectedNode {
 		t.Errorf("Expected ServiceNode %q, got: %q", expectedNode, sr.ServiceNode)
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Check that the ProtoPorts that are equal to 0 gets removed
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	if len(sr.ProtoPort) != 1 {
 		t.Errorf("Expected: one proto port (excluding 0s), got: %v", sr.ProtoPort)
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Check that the unit asset details exists and are ok
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	if v, ok := sr.Details["Test"]; !ok || len(v) != 1 {
 		t.Errorf("Missing or incorrect unit asset details. Expected: %v, got: %v", (*mua).GetDetails(), v)
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Check that the service forms exists and are ok
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	if v, ok := sr.Details["Forms"]; !ok || len(v) != 1 {
 		t.Errorf("Missing or incorrect service forms. Expected: %v, got: %v", (*serv).Details, v)
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: Sent in version is not supported
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	version = "UnknownVersion"
 	_, err = serviceRegistrationForm(&testSys, mua, serv, version)
 	if err == nil {
@@ -251,10 +101,7 @@ func TestForserviceRegistrationForm(t *testing.T) {
 		t.Errorf("Expected error: unsupported service registration form version, got: %v", err)
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Check that when the Service RegPeriod equals 0, ServiceRegistrationForm defaults to its RegLife default value of 30
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	(*testSys.UAssets["testUnitAsset"]).GetServices()["test"].RegPeriod = 0
 	version = "ServiceRecord_v1"
 	payload, err = serviceRegistrationForm(&testSys, mua, serv, version)
@@ -270,12 +117,10 @@ func TestForserviceRegistrationForm(t *testing.T) {
 	}
 }
 
-func TestForderegisterService(t *testing.T) {
+func TestUnregisterService(t *testing.T) {
 	testSys := createTestSystem(false)
-
-	var registrar *components.CoreSystem
+	registrar := testSys.CoreS[0].Url
 	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
-
 	respFunc := func() *http.Response {
 		return &http.Response{
 			Status:     "200 OK",
@@ -284,45 +129,30 @@ func TestForderegisterService(t *testing.T) {
 		}
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Good case: No errors when a service not registered tries to get deregistered
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 0, nil)
-
-	err := deregisterService(registrar, serv)
+	err := unregisterService(registrar, serv)
 	if err != nil {
 		t.Errorf("Expected error: %v, got: %v", nil, err)
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Good case: No errors when a service registered tries to get deregistered
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	registrar = testSys.CoreS[0]
-
-	err = deregisterService(registrar, serv)
+	err = unregisterService(registrar, serv)
 	if err != nil {
 		t.Errorf("Expected error: %v, got: %v", nil, err)
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// bad case: response body error
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 1, errHTTP)
-	err = deregisterService(registrar, serv)
+	err = unregisterService(registrar, serv)
 	if err == nil {
 		t.Errorf("Expected error while sending http request")
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// bad case: URL broken
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 0, nil)
-	registrar.Url = brokenUrl
-	err = deregisterService(registrar, serv)
+	registrar = brokenUrl
+	err = unregisterService(registrar, serv)
 	if err == nil {
 		t.Errorf("Expected error while creating http request")
 	}
@@ -332,31 +162,25 @@ func TestServiceRegistrationFormList(t *testing.T) {
 	list := []string{
 		"ServiceRecord_v1",
 	}
-
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Check that the return value of ServiceRegistrationFormsList is equal to the expected list of ServiceRegistrationForms
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	test := ServiceRegistrationFormsList()
 	if !reflect.DeepEqual(list, test) {
 		t.Errorf("Expected lists to be equal. Expected: %v, got: %v", list, test)
 	}
 }
 
-func TestForregisterService(t *testing.T) {
+func TestRegisterService(t *testing.T) {
 	testSys := createTestSystem(false)
+	registrar := testSys.CoreS[0].Url
 	mua := testSys.UAssets["testUnitAsset"]
 	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
-	registrar := testSys.CoreS[0]
 
 	payload, err := serviceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
-
 	if err != nil {
 		t.Fatalf("The Service Record version was wrong.")
 	}
-
 	var sr forms.ServiceRecord_v1
-	if err := json.Unmarshal(payload, &sr); err != nil {
+	if err = json.Unmarshal(payload, &sr); err != nil {
 		t.Fatalf("Invalid JSON: %v", err)
 	}
 
@@ -375,43 +199,33 @@ func TestForregisterService(t *testing.T) {
 		}
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Good case, everything works, service gets registered
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 0, nil)
-
-	test := registerService(&testSys, mua, serv, registrar)
+	test := registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) > 0 {
 		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: when NewRequest with PUT method fails
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 0, nil)
-	registrar.Url = brokenUrl
-	test = registerService(&testSys, mua, serv, registrar)
+	registrar = brokenUrl
+	test = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since NewRequest with PUT method should have failed, got: %d", int(test.Seconds()))
 	}
-
-	registrar.Url = "https://leadingregistrar"
+	registrar = testSys.CoreS[0].Url
 	serv.ID = 0
 
 	payload, err = serviceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
-
 	if err != nil {
 		t.Fatalf("The Service Record version was wrong.")
 	}
 
-	if err := json.Unmarshal(payload, &sr); err != nil {
+	if err = json.Unmarshal(payload, &sr); err != nil {
 		t.Fatalf("Invalid JSON: %v", err)
 	}
 
 	sr.EndOfValidity = time.Now().Format(time.RFC3339)
-
 	fakeBody, err = json.Marshal(sr)
 	if err != nil {
 		t.Errorf("Fail Marshal at start of test")
@@ -425,47 +239,33 @@ func TestForregisterService(t *testing.T) {
 		}
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Good case when making POST instead
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 0, nil)
-
-	test = registerService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) > 0 {
 		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: when NewRequest with POST method fails
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 0, nil)
-
-	registrar.Url = brokenUrl
-	test = registerService(&testSys, mua, serv, registrar)
+	registrar = brokenUrl
+	test = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since NewRequest with POST method should have failed, got: %d", int(test.Seconds()))
 	}
+	registrar = testSys.CoreS[0].Url
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: when http.DefaultClient.Do() fails with a err.Timeout()
-	// -- -- -- -- -- -- -- -- -- -- //
-
-	registrar.Url = "https://leadingregistrar"
 	timeoutErr := timeoutError{}
 	newMockTransport(respFunc, 1, timeoutErr)
-	test = registerService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: when http.DefaultClient.Do() fails but not with a err.Timeout()
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 1, errHTTP)
-	test = registerService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
 	}
@@ -479,13 +279,9 @@ func TestForregisterService(t *testing.T) {
 		}
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: when io.ReadAll() returns an error
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 0, nil)
-
-	test = registerService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the io.ReadAll() call should fail, got %d", int(test.Seconds()))
 	}
@@ -499,13 +295,9 @@ func TestForregisterService(t *testing.T) {
 		}
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: when Unpack() fails because of a non-existent "Content-Type" in the Header of the response
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 0, nil)
-
-	test = registerService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the Header had a non-existent/invalid Content-Type, got: %d", int(test.Seconds()))
 	}
@@ -524,13 +316,9 @@ func TestForregisterService(t *testing.T) {
 		}
 	}
 
-	// -- -- -- -- -- -- -- -- -- -- //
 	// Bad case: Error parsing the EndOfValidity into the RFC3339 time format
-	// -- -- -- -- -- -- -- -- -- -- //
-
 	newMockTransport(respFunc, 0, nil)
-
-	test = registerService(&testSys, mua, serv, registrar)
+	test = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the EndOfValidity has a faulty time format, got: %d", int(test.Seconds()))
 	}

From 37d929a2b2dd4942ee4fe0cff42b98cff2b6d382 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 22 Jun 2025 18:48:49 +0200
Subject: [PATCH 065/186] Fixes a linter error for URL string

---
 usecases/authentication.go | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/usecases/authentication.go b/usecases/authentication.go
index 8514f32..d37d1ce 100644
--- a/usecases/authentication.go
+++ b/usecases/authentication.go
@@ -132,7 +132,13 @@ func sendCSR(sys *components.System, csrPEM []byte) (string, error) {
 	}
 	url += "/certify"
 
-	resp, err := http.Post(url, "application/x-pem-file", bytes.NewReader(csrPEM))
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(csrPEM))
+	if err != nil {
+		log.Printf("Error creating request: %v", err)
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/x-pem-file")
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return "", fmt.Errorf("failed to send CSR: %w", err)
 	}
@@ -166,7 +172,7 @@ func getCACertificate(sys *components.System) (string, error) {
 	// Make a GET request to the CA's endpoint
 	req, err := http.NewRequest(http.MethodGet, url, nil)
 	if err != nil {
-		log.Printf("Error creating NewRequest: %v", err)
+		log.Printf("Error creating request: %v", err)
 		return "", err
 	}
 	resp, err := http.DefaultClient.Do(req)

From 950c3f2e3c88f7774dd6c51db0f13212f4bf49c9 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Wed, 18 Jun 2025 09:10:28 +0200
Subject: [PATCH 066/186] Slight changes to Configure()

---
 usecases/configuration.go      | 18 ++++++++++--------
 usecases/configuration_test.go | 13 +++++++++++++
 2 files changed, 23 insertions(+), 8 deletions(-)
 create mode 100644 usecases/configuration_test.go

diff --git a/usecases/configuration.go b/usecases/configuration.go
index a479e05..98c1e03 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -116,7 +116,10 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 
 	var rawBytes []json.RawMessage // the mbaigo library does not know about the unit asset's structure (defined in the file thing.go and not part of the library)
 
-	// open the configuration file or create one with the default content prepared above
+	// TODO: open the configuration file or create one with the default content prepared above
+	// os.OpenFile can do both open and create in the same command, ensuring one of them happens, depending on
+	// wether or not the file exists
+	// https://pkg.go.dev/os#OpenFile
 	systemConfigFile, err := os.Open("systemconfig.json")
 
 	if err != nil { // could not find the systemconfig.json so a default one is being created
@@ -125,15 +128,14 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 			return rawBytes, err
 		}
 		defer defaultConfigFile.Close()
-		systemconfigjson, err := json.MarshalIndent(defaultConfig, "", "     ")
-		if err != nil {
-			return rawBytes, err
-		}
-		nBytes, err := defaultConfigFile.Write(systemconfigjson)
+
+		enc := json.NewEncoder(defaultConfigFile) // Create an encoder that allows writing to a file
+		enc.SetIndent("", "     ")                // Set proper indentation
+		err = enc.Encode(defaultConfig)           // Write defaultConfig template to file
 		if err != nil {
-			return rawBytes, err
+			return nil, fmt.Errorf("jsonEncode: %w", err)
 		}
-		return rawBytes, fmt.Errorf("a new configuration file has been written with %d bytes. Please update it and restart the system", nBytes)
+		return nil, fmt.Errorf("a new configuration file has been created. Please update it and restart the system")
 	}
 
 	// the system configuration file could be open, read the configurations and pass them on to the system
diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
new file mode 100644
index 0000000..8c858b6
--- /dev/null
+++ b/usecases/configuration_test.go
@@ -0,0 +1,13 @@
+package usecases
+
+import "testing"
+
+func TestConfigure(t *testing.T) {
+	
+}
+
+func TestGetServiceList(t *testing.T) {
+}
+
+func TestMakeServiceMap(t *testing.T) {
+}
\ No newline at end of file

From 92c5dd606ff33f88818694bd3abf84fbfe53b553 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Wed, 18 Jun 2025 17:36:26 +0200
Subject: [PATCH 067/186] Added tests for getServiceList() and
 MakeServiceMap(), started creating test for Configure()

---
 usecases/configuration.go      |   5 --
 usecases/configuration_test.go | 113 ++++++++++++++++++++++++++++++++-
 2 files changed, 111 insertions(+), 7 deletions(-)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index 98c1e03..57c7013 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -116,12 +116,7 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 
 	var rawBytes []json.RawMessage // the mbaigo library does not know about the unit asset's structure (defined in the file thing.go and not part of the library)
 
-	// TODO: open the configuration file or create one with the default content prepared above
-	// os.OpenFile can do both open and create in the same command, ensuring one of them happens, depending on
-	// wether or not the file exists
-	// https://pkg.go.dev/os#OpenFile
 	systemConfigFile, err := os.Open("systemconfig.json")
-
 	if err != nil { // could not find the systemconfig.json so a default one is being created
 		defaultConfigFile, err := os.Create("systemconfig.json")
 		if err != nil {
diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index 8c858b6..c2f5b63 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -1,13 +1,122 @@
 package usecases
 
-import "testing"
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"testing"
+
+	"github.com/sdoque/mbaigo/components"
+)
+
+func createDefaultConfig(sys components.System) {
+	var defaultConfig templateOut
+
+	var assetTemplate components.UnitAsset
+	for _, ua := range sys.UAssets {
+		assetTemplate = *ua // this creates a copy (value, not reference)
+		break               // stop after the first entry
+	}
+	servicesTemplate := getServicesList(assetTemplate)
+
+	confAsset := ConfigurableAsset{
+		Name:     assetTemplate.GetName(),
+		Details:  assetTemplate.GetDetails(),
+		Services: servicesTemplate,
+	}
+
+	// If the asset exposes traits, serialize them and store as raw JSON
+	if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
+		if traits := assetWithTraits.GetTraits(); traits != nil {
+			traitJSON, err := json.Marshal(traits)
+			if err == nil {
+				confAsset.Traits = []json.RawMessage{traitJSON}
+			} else {
+				fmt.Println("Warning: could not marshal traits:", err)
+			}
+		}
+	}
+
+	defaultConfig.CName = sys.Name
+	defaultConfig.Protocols = sys.Husk.ProtoPort
+	defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
+
+	defaultConfigFile, err := os.Create("systemconfig.json")
+	if err != nil {
+		log.Fatalf("Encountered error while creating default config file")
+	}
+	defer defaultConfigFile.Close()
+
+	enc := json.NewEncoder(defaultConfigFile) // Create an encoder that allows writing to a file
+	enc.SetIndent("", "     ")                // Set proper indentation
+	err = enc.Encode(defaultConfig)           // Write defaultConfig template to file
+	if err != nil {
+		log.Fatalf("jsonEncode: %v", err)
+	}
+}
 
 func TestConfigure(t *testing.T) {
+	// 1, Best case
+	os.Remove("systemconfig.json")
+	testSys := createTestSystem(false)
+	createDefaultConfig(testSys)
+	_, err := Configure(&testSys)
+	if err != nil {
+		t.Errorf("Expected no errors in best case, got: %#v", err)
+	}
+
+	// 2, Missing config
+	os.Remove("systemconfig.json")
+	_, err = Configure(&testSys)
+	if err == nil {
+		t.Errorf("Expected error because of missing config")
+	}
+
+	// 2.1, Missing config ( Breaking os.Create() )
+	os.Remove("systemconfig.json")
+	// Create a file that noone has permissions to open, should break os.Open()
+	os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0000)
+	_, err = Configure(&testSys)
+	if err == nil {
+		t.Errorf("Expected error while creating config")
+	}
+
+	// 2.2, Missing config ( Breaking encode to file )
+	// Allow read, but not write?
 	
 }
 
 func TestGetServiceList(t *testing.T) {
+	// getServicesList(uat components.UnitAsset) []components.Service
+	testSys := createTestSystem(false)
+	ua := (*testSys.UAssets["testUnitAsset"])
+	servList := getServicesList(ua)
+	if len(servList) != 1 && servList[0].Definition != "test" {
+		t.Errorf("Expected length: 1, got %d\tExpected 'Definition': test, got %s", len(servList), servList[0].Definition)
+	}
 }
 
 func TestMakeServiceMap(t *testing.T) {
-}
\ No newline at end of file
+	var servList []components.Service
+	for x := range 6 {
+		serv := components.Service{
+			ID:            x,
+			Definition:    fmt.Sprintf("testDef%d", x),
+			SubPath:       fmt.Sprintf("test%d", x),
+			Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+			Description:   fmt.Sprintf("test service %d", x),
+			RegPeriod:     45,
+			RegTimestamp:  "now",
+			RegExpiration: "45",
+		}
+		servList = append(servList, serv)
+	}
+	servMap := MakeServiceMap(servList)
+	for c := range 6 {
+		service := fmt.Sprintf("test%d", c)
+		if servMap[service].SubPath != service || servMap[service].ID != c {
+			t.Errorf(`Expected servMap["%s"].SubPath to be "%s", with ID: "%d". Got Subpath: "%s", with ID: "%d"`, service, service, c, servMap[service].SubPath, servMap[service].ID)
+		}
+	}
+}

From 7dab0961715c9ab4aec403f671d7a1658145f540 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 19 Jun 2025 11:39:10 +0200
Subject: [PATCH 068/186] WIP, tests for Configure()

---
 usecases/configuration_test.go | 142 ++++++++++++++++++++++++++++++---
 1 file changed, 133 insertions(+), 9 deletions(-)

diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index c2f5b63..04b2586 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -4,13 +4,47 @@ import (
 	"encoding/json"
 	"fmt"
 	"log"
+	"net/http"
 	"os"
 	"testing"
 
 	"github.com/sdoque/mbaigo/components"
 )
 
-func createDefaultConfig(sys components.System) {
+// A mocked UnitAsset used for testing
+type mockUnitAssetWithTraits struct {
+	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
+	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
+	Details     map[string][]string `json:"details"` // Metadata or details about this UA
+	ServicesMap components.Services `json:"-"`
+	CervicesMap components.Cervices `json:"-"`
+	Traits      map[string][]string `json:"-"`
+}
+
+func (mua mockUnitAssetWithTraits) GetTraits() any {
+	return mua.Traits
+}
+
+func (mua mockUnitAssetWithTraits) GetName() string {
+	return mua.Name
+}
+
+func (mua mockUnitAssetWithTraits) GetServices() components.Services {
+	return mua.ServicesMap
+}
+
+func (mua mockUnitAssetWithTraits) GetCervices() components.Cervices {
+	return mua.CervicesMap
+}
+
+func (mua mockUnitAssetWithTraits) GetDetails() map[string][]string {
+	return mua.Details
+}
+
+func (mua mockUnitAssetWithTraits) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
+}
+
+func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 	var defaultConfig templateOut
 
 	var assetTemplate components.UnitAsset
@@ -26,6 +60,41 @@ func createDefaultConfig(sys components.System) {
 		Services: servicesTemplate,
 	}
 
+	sys.UAssets = make(map[string]*components.UnitAsset)
+	if assetTrait == true {
+		// Create one asset with traits, if it's needed for test
+		testCerv := &components.Cervice{
+			Definition: "testCerv",
+			Details:    map[string][]string{"Forms": {"SignalA_v1a"}},
+			Nodes:      map[string][]string{},
+		}
+		CervicesMap := &components.Cervices{
+			testCerv.Definition: testCerv,
+		}
+		setTest := &components.Service{
+			ID:            1,
+			Definition:    "test",
+			SubPath:       "test",
+			Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+			Description:   "A test service",
+			RegPeriod:     45,
+			RegTimestamp:  "now",
+			RegExpiration: "45",
+		}
+		ServicesMap := &components.Services{
+			setTest.SubPath: setTest,
+		}
+		mua := &mockUnitAssetWithTraits{
+			Name:        "testUnitAsset",
+			Details:     map[string][]string{"Test": {"Test"}},
+			ServicesMap: *ServicesMap,
+			CervicesMap: *CervicesMap,
+			Traits:      map[string][]string{"Trait": {"testTrait"}},
+		}
+		var muaInterface components.UnitAsset = mua
+		sys.UAssets[mua.GetName()] = &muaInterface
+	}
+
 	// If the asset exposes traits, serialize them and store as raw JSON
 	if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
 		if traits := assetWithTraits.GetTraits(); traits != nil {
@@ -37,11 +106,46 @@ func createDefaultConfig(sys components.System) {
 			}
 		}
 	}
+	for x := range assetAmount {
+		// Create one asset with traits, if it's needed for test
+		testCerv := &components.Cervice{
+			Definition: fmt.Sprintf("testCerv%d", x),
+			Details:    map[string][]string{"Forms": {"SignalA_v1a"}},
+			Nodes:      map[string][]string{},
+		}
+		CervicesMap := &components.Cervices{
+			testCerv.Definition: testCerv,
+		}
+		setTest := &components.Service{
+			ID:            x,
+			Definition:    fmt.Sprintf("test%d", x),
+			SubPath:       fmt.Sprintf("test%d", x),
+			Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+			Description:   "A test service",
+			RegPeriod:     45,
+			RegTimestamp:  "now",
+			RegExpiration: "45",
+		}
+		ServicesMap := &components.Services{
+			setTest.SubPath: setTest,
+		}
+		mua := &mockUnitAssetWithTraits{
+			Name:        fmt.Sprintf("testUnitAsset%d", x),
+			Details:     map[string][]string{"Test": {"Test"}},
+			ServicesMap: *ServicesMap,
+			CervicesMap: *CervicesMap,
+			Traits:      map[string][]string{"Trait": {"testTrait"}},
+		}
+
+		var muaInterface components.UnitAsset = mua
+		sys.UAssets[mua.GetName()] = &muaInterface
+	}
 
 	defaultConfig.CName = sys.Name
 	defaultConfig.Protocols = sys.Husk.ProtoPort
 	defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
 
+	os.Remove("systemconfig.json")
 	defaultConfigFile, err := os.Create("systemconfig.json")
 	if err != nil {
 		log.Fatalf("Encountered error while creating default config file")
@@ -58,33 +162,53 @@ func createDefaultConfig(sys components.System) {
 
 func TestConfigure(t *testing.T) {
 	// 1, Best case
-	os.Remove("systemconfig.json")
 	testSys := createTestSystem(false)
-	createDefaultConfig(testSys)
+	createConfig(&testSys, false, 1)
 	_, err := Configure(&testSys)
 	if err != nil {
 		t.Errorf("Expected no errors in best case, got: %#v", err)
 	}
 
-	// 2, Missing config
+	// 1.1, Asset has traits, good case
+	createConfig(&testSys, true, 0)
+	_, err = Configure(&testSys)
+	if err != nil {
+		t.Errorf("Expected no errors while having traits, got: %#v", err)
+	}
+
+	// 2, Asset with traits (can't break Marshal currently)
+
+	// 3, Missing config
 	os.Remove("systemconfig.json")
 	_, err = Configure(&testSys)
 	if err == nil {
 		t.Errorf("Expected error because of missing config")
 	}
 
-	// 2.1, Missing config ( Breaking os.Create() )
+	// 3.1, Missing config ( Breaking os.Create() )
 	os.Remove("systemconfig.json")
-	// Create a file that noone has permissions to open, should break os.Open()
+	// Create a file that noone has permissions to open, should break os.Open() & os.Create()
 	os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0000)
 	_, err = Configure(&testSys)
 	if err == nil {
 		t.Errorf("Expected error while creating config")
 	}
 
-	// 2.2, Missing config ( Breaking encode to file )
-	// Allow read, but not write?
-	
+	// 3.2, Missing config ( Breaking encode to file )
+	// This could be done by including a test hook (os.Chmod(path, 0444)) which will change
+	// permission to read only, before the it starts writing with encode
+
+	// 4, Config file could be opened, but it failed while reading
+	// Could be done like above, change permission to 0000 so it cant be read
+
+	// 5, if len(aux.Resources) == 0, under Alias part
+	// no unit_assets present in the system
+	createConfig(&testSys, false, 0)
+	_, err = Configure(&testSys)
+	if err != nil {
+		t.Errorf("Expected no errors")
+	}
+
 }
 
 func TestGetServiceList(t *testing.T) {

From b9a303afe8b0925b8a8bfafba55d40931aa1b523 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 23 Jun 2025 15:20:16 +0200
Subject: [PATCH 069/186] Finished tests for Configure(), moved/refactored some
 code, added error check in configuration.go

---
 usecases/configuration.go      |  48 ++++----
 usecases/configuration_test.go | 196 ++++++++++++++++-----------------
 2 files changed, 117 insertions(+), 127 deletions(-)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index 57c7013..39d7b25 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -23,6 +23,7 @@ package usecases
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 
@@ -50,25 +51,27 @@ type templateOut struct {
 // Since it does not know about the details of the Thing, it does not unmarsahll this
 // information
 type configFileIn struct {
-	CName        string                  `json:"systemname"`
-	rawResources []json.RawMessage       `json:"-"`
-	Protocols    map[string]int          `json:"protocolsNports"`
-	CCoreS       []components.CoreSystem `json:"coreSystems"`
+	CName     string                  `json:"systemname"`
+	Protocols map[string]int          `json:"protocolsNports"`
+	CCoreS    []components.CoreSystem `json:"coreSystems"`
+	Resources []json.RawMessage       `json:"unit_assets"`
 }
 
+var ErrNewConfig = errors.New("a new configuration file has been created. Please update it and restart the system")
+
 // Configure reads the system configuration JSON file to get the deployment details.
 // If the file is missing, it generates a default systemconfig.json file and shuts down the system
 func Configure(sys *components.System) ([]json.RawMessage, error) {
-	// prepare content of configuration file
-	var defaultConfig templateOut
-
-	// var servicesList []components.Service // this is the list of services for each unit asset
-
 	var assetTemplate components.UnitAsset
+	if sys.UAssets == nil {
+		return nil, fmt.Errorf("unitAsset missing")
+	}
+
 	for _, ua := range sys.UAssets {
 		assetTemplate = *ua // this creates a copy (value, not reference)
 		break               // stop after the first entry
 	}
+
 	servicesTemplate := getServicesList(assetTemplate)
 
 	confAsset := ConfigurableAsset{
@@ -88,7 +91,8 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 			}
 		}
 	}
-
+	// prepare content of configuration file
+	var defaultConfig templateOut
 	defaultConfig.CName = sys.Name
 	defaultConfig.Protocols = sys.Husk.ProtoPort
 	defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
@@ -130,7 +134,7 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 		if err != nil {
 			return nil, fmt.Errorf("jsonEncode: %w", err)
 		}
-		return nil, fmt.Errorf("a new configuration file has been created. Please update it and restart the system")
+		return nil, ErrNewConfig
 	}
 
 	// the system configuration file could be open, read the configurations and pass them on to the system
@@ -140,32 +144,22 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 		return rawBytes, err
 	}
 
-	// the challenge is that the definition of the unit asset is unknown to the mbaigo library and only known to the system that invokes the library
 	var configurationIn configFileIn
-	// extract the information related to the system separately from the unit_assets (i.e., the resources)
-	type Alias configFileIn
-	aux := &struct {
-		Resources []json.RawMessage `json:"unit_assets"`
-		*Alias
-	}{
-		Alias: (*Alias)(&configurationIn),
-	}
-	if err := json.Unmarshal(configBytes, aux); err != nil {
+	if err := json.Unmarshal(configBytes, &configurationIn); err != nil {
 		return rawBytes, err
 	}
-	if len(aux.Resources) > 0 {
-		configurationIn.rawResources = aux.Resources
+	var rawResources []json.RawMessage
+	if len(configurationIn.Resources) > 0 {
+		rawResources = configurationIn.Resources
 	} else {
-		var rawMessages []json.RawMessage
 		for _, s := range defaultConfig.Assets {
 			// convert the struct to JSON-encoded byte array
 			jsonBytes, err := json.Marshal(s)
 			if err != nil {
 				fmt.Println("Failed to marshal struct:", err)
 			}
-			rawMessages = append(rawMessages, json.RawMessage(jsonBytes)) // append the json.RawMessage to the slice
+			rawResources = append(rawResources, json.RawMessage(jsonBytes)) // append the json.RawMessage to the slice
 		}
-		configurationIn.rawResources = rawMessages
 	}
 
 	sys.Name = configurationIn.CName
@@ -175,7 +169,7 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 		sys.CoreS = append(sys.CoreS, &newCore)
 	}
 
-	return configurationIn.rawResources, nil
+	return rawResources, nil
 }
 
 // getServicesList() returns the original list of services
diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index 04b2586..ee35654 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -2,6 +2,7 @@ package usecases
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"log"
 	"net/http"
@@ -60,17 +61,7 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 		Services: servicesTemplate,
 	}
 
-	sys.UAssets = make(map[string]*components.UnitAsset)
 	if assetTrait == true {
-		// Create one asset with traits, if it's needed for test
-		testCerv := &components.Cervice{
-			Definition: "testCerv",
-			Details:    map[string][]string{"Forms": {"SignalA_v1a"}},
-			Nodes:      map[string][]string{},
-		}
-		CervicesMap := &components.Cervices{
-			testCerv.Definition: testCerv,
-		}
 		setTest := &components.Service{
 			ID:            1,
 			Definition:    "test",
@@ -88,63 +79,60 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 			Name:        "testUnitAsset",
 			Details:     map[string][]string{"Test": {"Test"}},
 			ServicesMap: *ServicesMap,
-			CervicesMap: *CervicesMap,
+			CervicesMap: nil,
 			Traits:      map[string][]string{"Trait": {"testTrait"}},
 		}
 		var muaInterface components.UnitAsset = mua
 		sys.UAssets[mua.GetName()] = &muaInterface
+		// If the asset exposes traits, serialize them and store as raw JSON
+		if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
+			if traits := assetWithTraits.GetTraits(); traits != nil {
+				traitJSON, err := json.Marshal(traits)
+				if err == nil {
+					confAsset.Traits = []json.RawMessage{traitJSON}
+				} else {
+					fmt.Println("Warning: could not marshal traits:", err)
+				}
+			}
+		}
+		defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
 	}
 
-	// If the asset exposes traits, serialize them and store as raw JSON
-	if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
-		if traits := assetWithTraits.GetTraits(); traits != nil {
-			traitJSON, err := json.Marshal(traits)
-			if err == nil {
-				confAsset.Traits = []json.RawMessage{traitJSON}
-			} else {
-				fmt.Println("Warning: could not marshal traits:", err)
+	if assetAmount > 0 {
+		for x := range assetAmount {
+			setTest := components.Service{
+				ID:            x + 1,
+				Definition:    fmt.Sprintf("test%d", x+1),
+				SubPath:       fmt.Sprintf("test%d", x+1),
+				Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+				Description:   "A test service",
+				RegPeriod:     45,
+				RegTimestamp:  "now",
+				RegExpiration: "45",
+			}
+			servList := []components.Service{setTest}
+			mua := ConfigurableAsset{
+				Name:     fmt.Sprintf("testUnitAsset%d", x+1),
+				Details:  map[string][]string{"Test": {"Test"}},
+				Services: servList,
 			}
+
+			defaultConfig.Assets = append(defaultConfig.Assets, mua)
 		}
 	}
-	for x := range assetAmount {
-		// Create one asset with traits, if it's needed for test
-		testCerv := &components.Cervice{
-			Definition: fmt.Sprintf("testCerv%d", x),
-			Details:    map[string][]string{"Forms": {"SignalA_v1a"}},
-			Nodes:      map[string][]string{},
-		}
-		CervicesMap := &components.Cervices{
-			testCerv.Definition: testCerv,
-		}
-		setTest := &components.Service{
-			ID:            x,
-			Definition:    fmt.Sprintf("test%d", x),
-			SubPath:       fmt.Sprintf("test%d", x),
-			Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
-			Description:   "A test service",
-			RegPeriod:     45,
-			RegTimestamp:  "now",
-			RegExpiration: "45",
-		}
-		ServicesMap := &components.Services{
-			setTest.SubPath: setTest,
-		}
-		mua := &mockUnitAssetWithTraits{
-			Name:        fmt.Sprintf("testUnitAsset%d", x),
-			Details:     map[string][]string{"Test": {"Test"}},
-			ServicesMap: *ServicesMap,
-			CervicesMap: *CervicesMap,
-			Traits:      map[string][]string{"Trait": {"testTrait"}},
-		}
-
-		var muaInterface components.UnitAsset = mua
-		sys.UAssets[mua.GetName()] = &muaInterface
+	leadingRegistrar := components.CoreSystem{
+		Name: "serviceregistrar",
+		Url:  "https://leadingregistrar",
+	}
+	test := components.CoreSystem{
+		Name: "test",
+		Url:  "https://test",
 	}
 
+	defaultConfig.CCoreS = append(defaultConfig.CCoreS, leadingRegistrar)
+	defaultConfig.CCoreS = append(defaultConfig.CCoreS, test)
 	defaultConfig.CName = sys.Name
 	defaultConfig.Protocols = sys.Husk.ProtoPort
-	defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
-
 	os.Remove("systemconfig.json")
 	defaultConfigFile, err := os.Create("systemconfig.json")
 	if err != nil {
@@ -160,55 +148,63 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 	}
 }
 
-func TestConfigure(t *testing.T) {
-	// 1, Best case
-	testSys := createTestSystem(false)
-	createConfig(&testSys, false, 1)
-	_, err := Configure(&testSys)
-	if err != nil {
-		t.Errorf("Expected no errors in best case, got: %#v", err)
-	}
-
-	// 1.1, Asset has traits, good case
-	createConfig(&testSys, true, 0)
-	_, err = Configure(&testSys)
-	if err != nil {
-		t.Errorf("Expected no errors while having traits, got: %#v", err)
-	}
-
-	// 2, Asset with traits (can't break Marshal currently)
-
-	// 3, Missing config
-	os.Remove("systemconfig.json")
-	_, err = Configure(&testSys)
-	if err == nil {
-		t.Errorf("Expected error because of missing config")
-	}
+type configureParams struct {
+	testCase        string
+	brokenSystem    bool
+	assetHasTraits  bool
+	assetNumber     int
+	createNewConfig bool
+	allowConfigRead bool
+	expectError     bool
+}
 
-	// 3.1, Missing config ( Breaking os.Create() )
-	os.Remove("systemconfig.json")
-	// Create a file that noone has permissions to open, should break os.Open() & os.Create()
-	os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0000)
-	_, err = Configure(&testSys)
-	if err == nil {
-		t.Errorf("Expected error while creating config")
+func TestConfigure(t *testing.T) {
+	testParams := []configureParams{
+		// {testCase, brokenSystem, assetHasTraits, assetNumber, createNewConfig, allowConfigRead, expectError}
+		{"Best case, no errors", false, false, 1, true, true, false},
+		{"Missing asset", false, false, 0, false, true, true},
+		{"Good case, asset has traits", false, true, 0, true, true, false},
+		{"Config missing", false, false, 1, false, true, true},
+		{"Config missing, cant open or create", false, false, 1, false, false, true},
+		{"No Assets in config", false, false, 0, true, true, false},
+		{"Multiple Assets in config", false, false, 3, true, true, false},
 	}
-
-	// 3.2, Missing config ( Breaking encode to file )
-	// This could be done by including a test hook (os.Chmod(path, 0444)) which will change
-	// permission to read only, before the it starts writing with encode
-
-	// 4, Config file could be opened, but it failed while reading
-	// Could be done like above, change permission to 0000 so it cant be read
-
-	// 5, if len(aux.Resources) == 0, under Alias part
-	// no unit_assets present in the system
-	createConfig(&testSys, false, 0)
-	_, err = Configure(&testSys)
-	if err != nil {
-		t.Errorf("Expected no errors")
+	defer os.Remove("systemconfig.json")
+	for _, testCase := range testParams {
+		testSys := createTestSystem(false)
+		log.Printf("testSys: %#v", testSys.UAssets)
+		if testCase.testCase == "Missing asset" {
+			testSys.UAssets = nil
+		}
+		if testCase.createNewConfig == true {
+			createConfig(&testSys, testCase.assetHasTraits, testCase.assetNumber)
+		}
+		if testCase.allowConfigRead == false {
+			os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0000)
+		}
+		_, err := Configure(&testSys)
+		if testCase.expectError == false {
+			if err != nil {
+				t.Errorf("Expected no errors in best case, got: %#v", err)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("Expected errors in testcase '%s' got none", testCase.testCase)
+			}
+		}
+		if (testCase.createNewConfig == true) || (testCase.allowConfigRead == false) {
+			err = os.Remove("systemconfig.json")
+			if err != nil {
+				t.Fatalf("failed while removing file")
+			}
+		}
+		if errors.Is(err, ErrNewConfig) {
+			err = os.Remove("systemconfig.json")
+			if err != nil {
+				t.Fatalf("failed while removing file")
+			}
+		}
 	}
-
 }
 
 func TestGetServiceList(t *testing.T) {

From 11550c6d739d230c0152264157b32b886eeb036a Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 23 Jun 2025 15:26:12 +0200
Subject: [PATCH 070/186] removed an unnecessary log.printf() in test file

---
 usecases/configuration_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index ee35654..6b74b71 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -172,7 +172,6 @@ func TestConfigure(t *testing.T) {
 	defer os.Remove("systemconfig.json")
 	for _, testCase := range testParams {
 		testSys := createTestSystem(false)
-		log.Printf("testSys: %#v", testSys.UAssets)
 		if testCase.testCase == "Missing asset" {
 			testSys.UAssets = nil
 		}

From 9746c77ab53867430f8ba7cf5b591fdf4b184bd2 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 24 Jun 2025 03:46:45 +0200
Subject: [PATCH 071/186] Fixed some things from pull request reviews

---
 usecases/configuration.go      | 63 +++++++++--------------
 usecases/configuration_test.go | 94 ++++++++++++++++------------------
 2 files changed, 67 insertions(+), 90 deletions(-)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index 39d7b25..e1b1b81 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -64,12 +64,12 @@ var ErrNewConfig = errors.New("a new configuration file has been created. Please
 func Configure(sys *components.System) ([]json.RawMessage, error) {
 	var assetTemplate components.UnitAsset
 	if sys.UAssets == nil {
-		return nil, fmt.Errorf("unitAsset missing")
+		return nil, fmt.Errorf("unitAssets missing")
 	}
 
 	for _, ua := range sys.UAssets {
-		assetTemplate = *ua // this creates a copy (value, not reference)
-		break               // stop after the first entry
+		assetTemplate = *ua
+		break
 	}
 
 	servicesTemplate := getServicesList(assetTemplate)
@@ -118,47 +118,43 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 	coreSystems := []components.CoreSystem{servReg, orches, ca, maitreD}
 	defaultConfig.CCoreS = coreSystems
 
-	var rawBytes []json.RawMessage // the mbaigo library does not know about the unit asset's structure (defined in the file thing.go and not part of the library)
-
-	systemConfigFile, err := os.Open("systemconfig.json")
-	if err != nil { // could not find the systemconfig.json so a default one is being created
-		defaultConfigFile, err := os.Create("systemconfig.json")
-		if err != nil {
-			return rawBytes, err
-		}
-		defer defaultConfigFile.Close()
+	// 0600 allows sudo Read/Write permission (secure config file), but no R/W for groups and users, 0644 to allow R/W on sudo and only R on groups/users, 0666 for R/W permissions for everyone
+	systemConfigFile, err := os.OpenFile("systemconfig.json", os.O_RDONLY|os.O_CREATE|os.O_RDWR, 0600)
+	if err != nil {
+		return nil, fmt.Errorf("error while opening/creating systemconfig file, check permissions on config file")
+	}
+	defer systemConfigFile.Close()
 
-		enc := json.NewEncoder(defaultConfigFile) // Create an encoder that allows writing to a file
-		enc.SetIndent("", "     ")                // Set proper indentation
-		err = enc.Encode(defaultConfig)           // Write defaultConfig template to file
+	fileInfo, err := systemConfigFile.Stat() // *.Stat() returns fileInfo/stats
+	if err != nil {
+		return nil, fmt.Errorf("error occured while getting config file stats")
+	}
+	if fileInfo.Size() == 0 { // *.Size() returns the filesize (number bytes) as an int, 0 is an empty file
+		enc := json.NewEncoder(systemConfigFile)
+		enc.SetIndent("", "    ")
+		err = enc.Encode(defaultConfig) // Write default values into systemconfig since file was empty
 		if err != nil {
-			return nil, fmt.Errorf("jsonEncode: %w", err)
+			return nil, fmt.Errorf("error writing default values to system config")
 		}
 		return nil, ErrNewConfig
 	}
 
-	// the system configuration file could be open, read the configurations and pass them on to the system
-	defer systemConfigFile.Close()
-	configBytes, err := os.ReadFile("systemconfig.json")
+	var configurationIn configFileIn
+	err = json.NewDecoder(systemConfigFile).Decode(&configurationIn) // Read the contents of systemconfig into configurationIn
 	if err != nil {
-		return rawBytes, err
+		return nil, fmt.Errorf("error reading systemconfig: %v", err)
 	}
 
-	var configurationIn configFileIn
-	if err := json.Unmarshal(configBytes, &configurationIn); err != nil {
-		return rawBytes, err
-	}
 	var rawResources []json.RawMessage
-	if len(configurationIn.Resources) > 0 {
+	if len(configurationIn.Resources) > 0 { // If unit assets was present in systemconfig file, send those
 		rawResources = configurationIn.Resources
 	} else {
-		for _, s := range defaultConfig.Assets {
-			// convert the struct to JSON-encoded byte array
+		for _, s := range defaultConfig.Assets { // Otherwise send the system default
 			jsonBytes, err := json.Marshal(s)
 			if err != nil {
 				fmt.Println("Failed to marshal struct:", err)
 			}
-			rawResources = append(rawResources, json.RawMessage(jsonBytes)) // append the json.RawMessage to the slice
+			rawResources = append(rawResources, json.RawMessage(jsonBytes))
 		}
 	}
 
@@ -181,14 +177,3 @@ func getServicesList(uat components.UnitAsset) []components.Service {
 	}
 	return serviceList
 }
-
-// MakeServiceMap() creates a map of services from a slice of services
-// The map is indexed by the service subpath
-func MakeServiceMap(services []components.Service) map[string]*components.Service {
-	serviceMap := make(map[string]*components.Service)
-	for i := range services {
-		svc := services[i] // take the address of the element in the slice
-		serviceMap[svc.SubPath] = &svc
-	}
-	return serviceMap
-}
diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index 6b74b71..f2feb32 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -14,9 +14,9 @@ import (
 
 // A mocked UnitAsset used for testing
 type mockUnitAssetWithTraits struct {
-	Name        string              `json:"name"`    // Must be a unique name, ie. a sensor ID
-	Owner       *components.System  `json:"-"`       // The parent system this UA is part of
-	Details     map[string][]string `json:"details"` // Metadata or details about this UA
+	Name        string              `json:"name"`
+	Owner       *components.System  `json:"-"`
+	Details     map[string][]string `json:"details"`
 	ServicesMap components.Services `json:"-"`
 	CervicesMap components.Cervices `json:"-"`
 	Traits      map[string][]string `json:"-"`
@@ -50,8 +50,8 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 
 	var assetTemplate components.UnitAsset
 	for _, ua := range sys.UAssets {
-		assetTemplate = *ua // this creates a copy (value, not reference)
-		break               // stop after the first entry
+		assetTemplate = *ua
+		break
 	}
 	servicesTemplate := getServicesList(assetTemplate)
 
@@ -101,9 +101,9 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 	if assetAmount > 0 {
 		for x := range assetAmount {
 			setTest := components.Service{
-				ID:            x + 1,
-				Definition:    fmt.Sprintf("test%d", x+1),
-				SubPath:       fmt.Sprintf("test%d", x+1),
+				ID:            x,
+				Definition:    fmt.Sprintf("test%d", x),
+				SubPath:       fmt.Sprintf("test%d", x),
 				Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
 				Description:   "A test service",
 				RegPeriod:     45,
@@ -112,14 +112,14 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 			}
 			servList := []components.Service{setTest}
 			mua := ConfigurableAsset{
-				Name:     fmt.Sprintf("testUnitAsset%d", x+1),
+				Name:     fmt.Sprintf("testUnitAsset%d", x),
 				Details:  map[string][]string{"Test": {"Test"}},
 				Services: servList,
 			}
-
 			defaultConfig.Assets = append(defaultConfig.Assets, mua)
 		}
 	}
+
 	leadingRegistrar := components.CoreSystem{
 		Name: "serviceregistrar",
 		Url:  "https://leadingregistrar",
@@ -141,36 +141,36 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 	defer defaultConfigFile.Close()
 
 	enc := json.NewEncoder(defaultConfigFile) // Create an encoder that allows writing to a file
-	enc.SetIndent("", "     ")                // Set proper indentation
-	err = enc.Encode(defaultConfig)           // Write defaultConfig template to file
+	enc.SetIndent("", "     ")
+	err = enc.Encode(defaultConfig) // Write defaultConfig template to file
 	if err != nil {
 		log.Fatalf("jsonEncode: %v", err)
 	}
 }
 
 type configureParams struct {
-	testCase        string
-	brokenSystem    bool
 	assetHasTraits  bool
 	assetNumber     int
 	createNewConfig bool
 	allowConfigRead bool
 	expectError     bool
+	testCase        string
 }
 
 func TestConfigure(t *testing.T) {
 	testParams := []configureParams{
-		// {testCase, brokenSystem, assetHasTraits, assetNumber, createNewConfig, allowConfigRead, expectError}
-		{"Best case, no errors", false, false, 1, true, true, false},
-		{"Missing asset", false, false, 0, false, true, true},
-		{"Good case, asset has traits", false, true, 0, true, true, false},
-		{"Config missing", false, false, 1, false, true, true},
-		{"Config missing, cant open or create", false, false, 1, false, false, true},
-		{"No Assets in config", false, false, 0, true, true, false},
-		{"Multiple Assets in config", false, false, 3, true, true, false},
+		// {assetHasTraits, assetNumber, createNewConfig, allowConfigRead, expectError, testCase}
+		{false, 1, true, true, false, "Best case"},
+		{false, 0, false, true, true, "Missing asset"},
+		{true, 0, true, true, false, "Good case, asset has traits"},
+		{false, 1, false, true, true, "Config missing"},
+		{false, 1, false, false, true, "Config missing, cant open or create"},
+		{false, 0, true, true, false, "No Assets in config"},
+		{false, 3, true, true, false, "Multiple Assets in config"},
 	}
 	defer os.Remove("systemconfig.json")
 	for _, testCase := range testParams {
+		os.Remove("systemconfig.json")
 		testSys := createTestSystem(false)
 		if testCase.testCase == "Missing asset" {
 			testSys.UAssets = nil
@@ -184,7 +184,7 @@ func TestConfigure(t *testing.T) {
 		_, err := Configure(&testSys)
 		if testCase.expectError == false {
 			if err != nil {
-				t.Errorf("Expected no errors in best case, got: %#v", err)
+				t.Errorf("Expected no errors in '%s', got: %v", testCase.testCase, err)
 			}
 		} else {
 			if err == nil {
@@ -207,35 +207,27 @@ func TestConfigure(t *testing.T) {
 }
 
 func TestGetServiceList(t *testing.T) {
-	// getServicesList(uat components.UnitAsset) []components.Service
-	testSys := createTestSystem(false)
-	ua := (*testSys.UAssets["testUnitAsset"])
-	servList := getServicesList(ua)
-	if len(servList) != 1 && servList[0].Definition != "test" {
-		t.Errorf("Expected length: 1, got %d\tExpected 'Definition': test, got %s", len(servList), servList[0].Definition)
+	setTest := &components.Service{
+		ID:            1,
+		Definition:    "test",
+		SubPath:       "test",
+		Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+		Description:   "A test service",
+		RegPeriod:     45,
+		RegTimestamp:  "now",
+		RegExpiration: "45",
 	}
-}
-
-func TestMakeServiceMap(t *testing.T) {
-	var servList []components.Service
-	for x := range 6 {
-		serv := components.Service{
-			ID:            x,
-			Definition:    fmt.Sprintf("testDef%d", x),
-			SubPath:       fmt.Sprintf("test%d", x),
-			Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
-			Description:   fmt.Sprintf("test service %d", x),
-			RegPeriod:     45,
-			RegTimestamp:  "now",
-			RegExpiration: "45",
-		}
-		servList = append(servList, serv)
+	ServicesMap := &components.Services{
+		setTest.SubPath: setTest,
 	}
-	servMap := MakeServiceMap(servList)
-	for c := range 6 {
-		service := fmt.Sprintf("test%d", c)
-		if servMap[service].SubPath != service || servMap[service].ID != c {
-			t.Errorf(`Expected servMap["%s"].SubPath to be "%s", with ID: "%d". Got Subpath: "%s", with ID: "%d"`, service, service, c, servMap[service].SubPath, servMap[service].ID)
-		}
+	mua := mockUnitAsset{
+		Name:        "test",
+		Owner:       nil,
+		Details:     nil,
+		ServicesMap: *ServicesMap,
+	}
+	servList := getServicesList(mua)
+	if len(servList) != 1 && servList[0].Definition != "test" {
+		t.Errorf("Expected length: 1, got %d\tExpected 'Definition': test, got %s", len(servList), servList[0].Definition)
 	}
 }

From 118aeb9e9771396ff4f3fe172be3240d9b7fdf94 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 24 Jun 2025 16:18:13 +0200
Subject: [PATCH 072/186] Added help function setupDefaultConfig()

---
 usecases/configuration.go | 90 +++++++++++++++++++++++++++++++++++----
 1 file changed, 81 insertions(+), 9 deletions(-)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index e1b1b81..9ecdd42 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -57,7 +57,70 @@ type configFileIn struct {
 	Resources []json.RawMessage       `json:"unit_assets"`
 }
 
-var ErrNewConfig = errors.New("a new configuration file has been created. Please update it and restart the system")
+var ErrNewConfig = errors.New("A new configuration file has been created. Please update it and restart the system")
+
+// TODO: Create setupDefaultConfig() to create a defaultConfig used to write default values to systemconfig in Configure().
+func setupDefaultConfig(sys *components.System) (defaultConfig templateOut, err error) {
+	var assetTemplate components.UnitAsset
+	if sys.UAssets == nil {
+		return defaultConfig, fmt.Errorf("unitAssets missing")
+	}
+
+	for _, ua := range sys.UAssets {
+		assetTemplate = *ua // this creates a copy (value, not reference)
+		break
+	}
+
+	servicesTemplate := getServicesList(assetTemplate)
+
+	confAsset := ConfigurableAsset{
+		Name:     assetTemplate.GetName(),
+		Details:  assetTemplate.GetDetails(),
+		Services: servicesTemplate,
+	}
+
+	// If the asset exposes traits, serialize them and store as raw JSON
+	if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
+		if traits := assetWithTraits.GetTraits(); traits != nil {
+			traitJSON, err := json.Marshal(traits)
+			if err != nil {
+				return defaultConfig, fmt.Errorf("couldn't marshal traits: %v", err)
+			}
+			confAsset.Traits = []json.RawMessage{traitJSON}
+		}
+	}
+
+	// prepare content of configuration file
+	defaultConfig.CName = sys.Name
+	defaultConfig.Protocols = sys.Husk.ProtoPort
+	defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
+
+	servReg := components.CoreSystem{
+		Name: "serviceregistrar",
+		Url:  "http://localhost:20102/serviceregistrar/registry",
+	}
+	orches := components.CoreSystem{
+		Name: "orchestrator",
+		Url:  "http://localhost:20103/orchestrator/orchestration",
+	}
+	ca := components.CoreSystem{
+		Name: "ca",
+		Url:  "http://localhost:20100/ca/certification",
+	}
+	maitreD := components.CoreSystem{
+		Name: "maitreD",
+		Url:  "http://localhost:20101/maitreD/maitreD",
+	}
+
+	// add the core systems to the configuration file
+	// the system is part of a local cloud with mandatory core systems
+	coreSystems := []components.CoreSystem{servReg, orches, ca, maitreD}
+	defaultConfig.CCoreS = coreSystems
+	return defaultConfig, nil
+}
+
+// TODO: Make a default config from tests branch, and use it to compare the systemconfig file created here against that,
+//       this ensures correct behaviour while creating a config.
 
 // Configure reads the system configuration JSON file to get the deployment details.
 // If the file is missing, it generates a default systemconfig.json file and shuts down the system
@@ -68,7 +131,7 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 	}
 
 	for _, ua := range sys.UAssets {
-		assetTemplate = *ua
+		assetTemplate = *ua // this creates a copy (value, not reference)
 		break
 	}
 
@@ -84,13 +147,13 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 	if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
 		if traits := assetWithTraits.GetTraits(); traits != nil {
 			traitJSON, err := json.Marshal(traits)
-			if err == nil {
-				confAsset.Traits = []json.RawMessage{traitJSON}
-			} else {
-				fmt.Println("Warning: could not marshal traits:", err)
+			if err != nil {
+				return nil, fmt.Errorf("couldn't marshal traits: %v", err)
 			}
+			confAsset.Traits = []json.RawMessage{traitJSON}
 		}
 	}
+
 	// prepare content of configuration file
 	var defaultConfig templateOut
 	defaultConfig.CName = sys.Name
@@ -113,13 +176,22 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 		Name: "maitreD",
 		Url:  "http://localhost:20101/maitreD/maitreD",
 	}
+
 	// add the core systems to the configuration file
 	// the system is part of a local cloud with mandatory core systems
 	coreSystems := []components.CoreSystem{servReg, orches, ca, maitreD}
 	defaultConfig.CCoreS = coreSystems
 
-	// 0600 allows sudo Read/Write permission (secure config file), but no R/W for groups and users, 0644 to allow R/W on sudo and only R on groups/users, 0666 for R/W permissions for everyone
-	systemConfigFile, err := os.OpenFile("systemconfig.json", os.O_RDONLY|os.O_CREATE|os.O_RDWR, 0600)
+	// TODO: Make sure this works like all the above code
+	/*
+		defaultConfig, err := setupDefaultConfig(sys)
+		if err != nil {
+			return nil, fmt.Errorf("couldn't create default config: %v", err)
+		}
+	*/
+
+	// 0600 allows user Read/Write permission (secure config file), but no R/W for groups and others, 0644 to allow R/W on sudo and only R on groups/others, 0666 for R/W permissions for everyone
+	systemConfigFile, err := os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0644)
 	if err != nil {
 		return nil, fmt.Errorf("error while opening/creating systemconfig file, check permissions on config file")
 	}
@@ -127,7 +199,7 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 
 	fileInfo, err := systemConfigFile.Stat() // *.Stat() returns fileInfo/stats
 	if err != nil {
-		return nil, fmt.Errorf("error occured while getting config file stats")
+		return nil, fmt.Errorf("error occurred while getting config file stats")
 	}
 	if fileInfo.Size() == 0 { // *.Size() returns the filesize (number bytes) as an int, 0 is an empty file
 		enc := json.NewEncoder(systemConfigFile)

From c06e42a1e9a23b39623cfcfc5ede2fc25dd6cb7f Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 24 Jun 2025 20:09:39 +0200
Subject: [PATCH 073/186] Fixed some PR comments, added help func
 setupDefaultConfig()

---
 usecases/configuration.go      |  72 +------------
 usecases/configuration_test.go | 180 ++++++++++++++++++++++++++-------
 2 files changed, 145 insertions(+), 107 deletions(-)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index 9ecdd42..7d137c8 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -59,7 +59,6 @@ type configFileIn struct {
 
 var ErrNewConfig = errors.New("A new configuration file has been created. Please update it and restart the system")
 
-// TODO: Create setupDefaultConfig() to create a defaultConfig used to write default values to systemconfig in Configure().
 func setupDefaultConfig(sys *components.System) (defaultConfig templateOut, err error) {
 	var assetTemplate components.UnitAsset
 	if sys.UAssets == nil {
@@ -119,79 +118,16 @@ func setupDefaultConfig(sys *components.System) (defaultConfig templateOut, err
 	return defaultConfig, nil
 }
 
-// TODO: Make a default config from tests branch, and use it to compare the systemconfig file created here against that,
-//       this ensures correct behaviour while creating a config.
-
 // Configure reads the system configuration JSON file to get the deployment details.
 // If the file is missing, it generates a default systemconfig.json file and shuts down the system
 func Configure(sys *components.System) ([]json.RawMessage, error) {
-	var assetTemplate components.UnitAsset
-	if sys.UAssets == nil {
-		return nil, fmt.Errorf("unitAssets missing")
-	}
-
-	for _, ua := range sys.UAssets {
-		assetTemplate = *ua // this creates a copy (value, not reference)
-		break
-	}
-
-	servicesTemplate := getServicesList(assetTemplate)
-
-	confAsset := ConfigurableAsset{
-		Name:     assetTemplate.GetName(),
-		Details:  assetTemplate.GetDetails(),
-		Services: servicesTemplate,
-	}
-
-	// If the asset exposes traits, serialize them and store as raw JSON
-	if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
-		if traits := assetWithTraits.GetTraits(); traits != nil {
-			traitJSON, err := json.Marshal(traits)
-			if err != nil {
-				return nil, fmt.Errorf("couldn't marshal traits: %v", err)
-			}
-			confAsset.Traits = []json.RawMessage{traitJSON}
-		}
-	}
-
-	// prepare content of configuration file
-	var defaultConfig templateOut
-	defaultConfig.CName = sys.Name
-	defaultConfig.Protocols = sys.Husk.ProtoPort
-	defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
-
-	servReg := components.CoreSystem{
-		Name: "serviceregistrar",
-		Url:  "http://localhost:20102/serviceregistrar/registry",
-	}
-	orches := components.CoreSystem{
-		Name: "orchestrator",
-		Url:  "http://localhost:20103/orchestrator/orchestration",
-	}
-	ca := components.CoreSystem{
-		Name: "ca",
-		Url:  "http://localhost:20100/ca/certification",
-	}
-	maitreD := components.CoreSystem{
-		Name: "maitreD",
-		Url:  "http://localhost:20101/maitreD/maitreD",
+	defaultConfig, err := setupDefaultConfig(sys)
+	if err != nil {
+		return nil, fmt.Errorf("couldn't create default config: %v", err)
 	}
 
-	// add the core systems to the configuration file
-	// the system is part of a local cloud with mandatory core systems
-	coreSystems := []components.CoreSystem{servReg, orches, ca, maitreD}
-	defaultConfig.CCoreS = coreSystems
-
-	// TODO: Make sure this works like all the above code
-	/*
-		defaultConfig, err := setupDefaultConfig(sys)
-		if err != nil {
-			return nil, fmt.Errorf("couldn't create default config: %v", err)
-		}
-	*/
-
 	// 0600 allows user Read/Write permission (secure config file), but no R/W for groups and others, 0644 to allow R/W on sudo and only R on groups/others, 0666 for R/W permissions for everyone
-	systemConfigFile, err := os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0644)
+	systemConfigFile, err := os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0600)
 	if err != nil {
 		return nil, fmt.Errorf("error while opening/creating systemconfig file, check permissions on config file")
 	}
diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index f2feb32..03b06b8 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -7,6 +7,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"reflect"
 	"testing"
 
 	"github.com/sdoque/mbaigo/components"
@@ -45,7 +46,7 @@ func (mua mockUnitAssetWithTraits) GetDetails() map[string][]string {
 func (mua mockUnitAssetWithTraits) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
 }
 
-func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
+func createConfigHasTraits(sys *components.System) {
 	var defaultConfig templateOut
 
 	var assetTemplate components.UnitAsset
@@ -61,8 +62,81 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 		Services: servicesTemplate,
 	}
 
-	if assetTrait == true {
-		setTest := &components.Service{
+	setTest := &components.Service{
+		ID:            1,
+		Definition:    "test",
+		SubPath:       "test",
+		Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+		Description:   "A test service",
+		RegPeriod:     45,
+		RegTimestamp:  "now",
+		RegExpiration: "45",
+	}
+	ServicesMap := &components.Services{
+		setTest.SubPath: setTest,
+	}
+	mua := &mockUnitAssetWithTraits{
+		Name:        "testUnitAsset",
+		Details:     map[string][]string{"Test": {"Test"}},
+		ServicesMap: *ServicesMap,
+		CervicesMap: nil,
+		Traits:      map[string][]string{"Trait": {"testTrait"}},
+	}
+	var muaInterface components.UnitAsset = mua
+	sys.UAssets[mua.GetName()] = &muaInterface
+	// If the asset exposes traits, serialize them and store as raw JSON
+	if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
+		if traits := assetWithTraits.GetTraits(); traits != nil {
+			traitJSON, err := json.Marshal(traits)
+			if err == nil {
+				confAsset.Traits = []json.RawMessage{traitJSON}
+			} else {
+				fmt.Println("Warning: could not marshal traits:", err)
+			}
+		}
+	}
+	defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
+
+	leadingRegistrar := components.CoreSystem{
+		Name: "serviceregistrar",
+		Url:  "http://localhost:20102/serviceregistrar/registry",
+	}
+	orchestrator := components.CoreSystem{
+		Name: "orchestrator",
+		Url:  "http://localhost:20103/orchestrator/orchestration",
+	}
+	ca := components.CoreSystem{
+		Name: "ca",
+		Url:  "http://localhost:20100/ca/certification",
+	}
+	maitreD := components.CoreSystem{
+		Name: "maitreD",
+		Url:  "http://localhost:20101/maitreD/maitreD",
+	}
+
+	defaultConfig.CCoreS = []components.CoreSystem{leadingRegistrar, orchestrator, ca, maitreD}
+	defaultConfig.CName = sys.Name
+	defaultConfig.Protocols = sys.Husk.ProtoPort
+	os.Remove("systemconfig.json")
+	defaultConfigFile, err := os.Create("systemconfig.json")
+	if err != nil {
+		log.Fatalf("Encountered error while creating default config file")
+	}
+	defer defaultConfigFile.Close()
+
+	enc := json.NewEncoder(defaultConfigFile) // Create an encoder that allows writing to a file
+	enc.SetIndent("", "     ")
+	err = enc.Encode(defaultConfig) // Write defaultConfig template to file
+	if err != nil {
+		log.Fatalf("jsonEncode: %v", err)
+	}
+}
+
+func createConfigNoTraits(sys *components.System, assetAmount int) {
+	var defaultConfig templateOut
+
+	if assetAmount == 1 {
+		setTest := components.Service{
 			ID:            1,
 			Definition:    "test",
 			SubPath:       "test",
@@ -72,33 +146,14 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 			RegTimestamp:  "now",
 			RegExpiration: "45",
 		}
-		ServicesMap := &components.Services{
-			setTest.SubPath: setTest,
-		}
-		mua := &mockUnitAssetWithTraits{
-			Name:        "testUnitAsset",
-			Details:     map[string][]string{"Test": {"Test"}},
-			ServicesMap: *ServicesMap,
-			CervicesMap: nil,
-			Traits:      map[string][]string{"Trait": {"testTrait"}},
-		}
-		var muaInterface components.UnitAsset = mua
-		sys.UAssets[mua.GetName()] = &muaInterface
-		// If the asset exposes traits, serialize them and store as raw JSON
-		if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
-			if traits := assetWithTraits.GetTraits(); traits != nil {
-				traitJSON, err := json.Marshal(traits)
-				if err == nil {
-					confAsset.Traits = []json.RawMessage{traitJSON}
-				} else {
-					fmt.Println("Warning: could not marshal traits:", err)
-				}
-			}
+		servList := []components.Service{setTest}
+		mua := ConfigurableAsset{
+			Name:     "testUnitAsset",
+			Details:  map[string][]string{"Test": {"Test"}},
+			Services: servList,
 		}
-		defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
-	}
-
-	if assetAmount > 0 {
+		defaultConfig.Assets = append(defaultConfig.Assets, mua)
+	} else {
 		for x := range assetAmount {
 			setTest := components.Service{
 				ID:            x,
@@ -122,15 +177,22 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 
 	leadingRegistrar := components.CoreSystem{
 		Name: "serviceregistrar",
-		Url:  "https://leadingregistrar",
+		Url:  "http://localhost:20102/serviceregistrar/registry",
+	}
+	orchestrator := components.CoreSystem{
+		Name: "orchestrator",
+		Url:  "http://localhost:20103/orchestrator/orchestration",
+	}
+	ca := components.CoreSystem{
+		Name: "ca",
+		Url:  "http://localhost:20100/ca/certification",
 	}
-	test := components.CoreSystem{
-		Name: "test",
-		Url:  "https://test",
+	maitreD := components.CoreSystem{
+		Name: "maitreD",
+		Url:  "http://localhost:20101/maitreD/maitreD",
 	}
 
-	defaultConfig.CCoreS = append(defaultConfig.CCoreS, leadingRegistrar)
-	defaultConfig.CCoreS = append(defaultConfig.CCoreS, test)
+	defaultConfig.CCoreS = []components.CoreSystem{leadingRegistrar, orchestrator, ca, maitreD}
 	defaultConfig.CName = sys.Name
 	defaultConfig.Protocols = sys.Husk.ProtoPort
 	os.Remove("systemconfig.json")
@@ -149,7 +211,7 @@ func createConfig(sys *components.System, assetTrait bool, assetAmount int) {
 }
 
 type configureParams struct {
-	assetHasTraits  bool
+	hasTraits       bool
 	assetNumber     int
 	createNewConfig bool
 	allowConfigRead bool
@@ -157,9 +219,45 @@ type configureParams struct {
 	testCase        string
 }
 
+// This is the config in string form from the original Configure()
+var expectedConf string = `map[coreSystems:[map[coreSystem:serviceregistrar url:http://localhost:20102/serviceregistrar/registry] map[coreSystem:orchestrator url:http://localhost:20103/orchestrator/orchestration] map[coreSystem:ca url:http://localhost:20100/ca/certification] map[coreSystem:maitreD url:http://localhost:20101/maitreD/maitreD]] protocolsNports:map[coap:0 http:1234 https:0] systemname:testSystem unit_assets:[map[details:map[Test:[Test]] name:testUnitAsset services:[map[costUnit: definition:test details:map[Forms:[SignalA_v1a]] registrationPeriod:45 subpath:test]] traits:<nil>]]]`
+
+// This test is to ensure that setupDefaultConfig() doesnt change the behaviour of of Config()
+func TestSetupDefaultConfig(t *testing.T) {
+	testSys := createTestSystem(false)
+
+	// Setup a default config with setupDefaultConfig() func
+	defConf, err := setupDefaultConfig(&testSys)
+	if err != nil {
+		t.Errorf("error in setupDefaultConfig() in test: %v", err)
+	}
+
+	def, err := os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0600)
+	if err != nil {
+		t.Errorf("error while opening/creating systemconfig.json in test")
+	}
+	defer def.Close()
+	// Write our defaultConfig to file with correct indent
+	enc := json.NewEncoder(def)
+	enc.SetIndent("", "     ")
+	enc.Encode(defConf)
+
+	// Decode to defaultConfig so we can compare the created default- and expected config
+	var defaultConfig any
+	def.Seek(0, 0)
+	json.NewDecoder(def).Decode(&defaultConfig)
+	os.Remove("systemconfig.json")
+
+	// Check if defaultConfig converted to a string is the same as the expectedConf
+	ok := reflect.DeepEqual(fmt.Sprintf("%v", defaultConfig), expectedConf)
+	if ok == false {
+		t.Errorf("systemconfig not equal")
+	}
+}
+
 func TestConfigure(t *testing.T) {
 	testParams := []configureParams{
-		// {assetHasTraits, assetNumber, createNewConfig, allowConfigRead, expectError, testCase}
+		// {hasTraits, assetNumber, createNewConfig, allowConfigRead, expectError, testCase}
 		{false, 1, true, true, false, "Best case"},
 		{false, 0, false, true, true, "Missing asset"},
 		{true, 0, true, true, false, "Good case, asset has traits"},
@@ -170,13 +268,17 @@ func TestConfigure(t *testing.T) {
 	}
 	defer os.Remove("systemconfig.json")
 	for _, testCase := range testParams {
-		os.Remove("systemconfig.json")
 		testSys := createTestSystem(false)
+		os.Remove("systemconfig.json")
 		if testCase.testCase == "Missing asset" {
 			testSys.UAssets = nil
 		}
 		if testCase.createNewConfig == true {
-			createConfig(&testSys, testCase.assetHasTraits, testCase.assetNumber)
+			if testCase.hasTraits == true {
+				createConfigHasTraits(&testSys)
+			} else {
+				createConfigNoTraits(&testSys, testCase.assetNumber)
+			}
 		}
 		if testCase.allowConfigRead == false {
 			os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0000)

From c8e519b91c99a18fad7f140aaf708bee04e7f293 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Wed, 25 Jun 2025 16:02:10 +0200
Subject: [PATCH 074/186] Big changes to test structure, added test for
 setupDefaultConfig()

---
 usecases/configuration.go      |   6 +-
 usecases/configuration_test.go | 201 +++++++++++++++++++++++----------
 2 files changed, 146 insertions(+), 61 deletions(-)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index 7d137c8..968e355 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -62,7 +62,7 @@ var ErrNewConfig = errors.New("A new configuration file has been created. Please
 func setupDefaultConfig(sys *components.System) (defaultConfig templateOut, err error) {
 	var assetTemplate components.UnitAsset
 	if sys.UAssets == nil {
-		return defaultConfig, fmt.Errorf("unitAssets missing")
+		return templateOut{}, fmt.Errorf("unitAssets missing")
 	}
 
 	for _, ua := range sys.UAssets {
@@ -83,7 +83,7 @@ func setupDefaultConfig(sys *components.System) (defaultConfig templateOut, err
 		if traits := assetWithTraits.GetTraits(); traits != nil {
 			traitJSON, err := json.Marshal(traits)
 			if err != nil {
-				return defaultConfig, fmt.Errorf("couldn't marshal traits: %v", err)
+				return templateOut{}, fmt.Errorf("couldn't marshal traits: %v", err)
 			}
 			confAsset.Traits = []json.RawMessage{traitJSON}
 		}
@@ -160,7 +160,7 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 		for _, s := range defaultConfig.Assets { // Otherwise send the system default
 			jsonBytes, err := json.Marshal(s)
 			if err != nil {
-				fmt.Println("Failed to marshal struct:", err)
+				return nil, fmt.Errorf("failed to marshal struct: %v", err)
 			}
 			rawResources = append(rawResources, json.RawMessage(jsonBytes))
 		}
diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index 03b06b8..bc5fc7e 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -2,12 +2,9 @@ package usecases
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
-	"log"
 	"net/http"
 	"os"
-	"reflect"
 	"testing"
 
 	"github.com/sdoque/mbaigo/components"
@@ -46,7 +43,7 @@ func (mua mockUnitAssetWithTraits) GetDetails() map[string][]string {
 func (mua mockUnitAssetWithTraits) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
 }
 
-func createConfigHasTraits(sys *components.System) {
+func createConfigHasTraits(sys *components.System) (err error) {
 	var defaultConfig templateOut
 
 	var assetTemplate components.UnitAsset
@@ -91,7 +88,7 @@ func createConfigHasTraits(sys *components.System) {
 			if err == nil {
 				confAsset.Traits = []json.RawMessage{traitJSON}
 			} else {
-				fmt.Println("Warning: could not marshal traits:", err)
+				return err
 			}
 		}
 	}
@@ -117,10 +114,9 @@ func createConfigHasTraits(sys *components.System) {
 	defaultConfig.CCoreS = []components.CoreSystem{leadingRegistrar, orchestrator, ca, maitreD}
 	defaultConfig.CName = sys.Name
 	defaultConfig.Protocols = sys.Husk.ProtoPort
-	os.Remove("systemconfig.json")
 	defaultConfigFile, err := os.Create("systemconfig.json")
 	if err != nil {
-		log.Fatalf("Encountered error while creating default config file")
+		return fmt.Errorf("Encountered error while creating default config file")
 	}
 	defer defaultConfigFile.Close()
 
@@ -128,11 +124,12 @@ func createConfigHasTraits(sys *components.System) {
 	enc.SetIndent("", "     ")
 	err = enc.Encode(defaultConfig) // Write defaultConfig template to file
 	if err != nil {
-		log.Fatalf("jsonEncode: %v", err)
+		return fmt.Errorf("jsonEncode: %v", err)
 	}
+	return
 }
 
-func createConfigNoTraits(sys *components.System, assetAmount int) {
+func createConfigNoTraits(sys *components.System, assetAmount int) (err error) {
 	var defaultConfig templateOut
 
 	if assetAmount == 1 {
@@ -195,10 +192,9 @@ func createConfigNoTraits(sys *components.System, assetAmount int) {
 	defaultConfig.CCoreS = []components.CoreSystem{leadingRegistrar, orchestrator, ca, maitreD}
 	defaultConfig.CName = sys.Name
 	defaultConfig.Protocols = sys.Husk.ProtoPort
-	os.Remove("systemconfig.json")
 	defaultConfigFile, err := os.Create("systemconfig.json")
 	if err != nil {
-		log.Fatalf("Encountered error while creating default config file")
+		return fmt.Errorf("Encountered error while creating default config file")
 	}
 	defer defaultConfigFile.Close()
 
@@ -206,24 +202,75 @@ func createConfigNoTraits(sys *components.System, assetAmount int) {
 	enc.SetIndent("", "     ")
 	err = enc.Encode(defaultConfig) // Write defaultConfig template to file
 	if err != nil {
-		log.Fatalf("jsonEncode: %v", err)
+		return fmt.Errorf("jsonEncode: %v", err)
 	}
-}
-
-type configureParams struct {
-	hasTraits       bool
-	assetNumber     int
-	createNewConfig bool
-	allowConfigRead bool
-	expectError     bool
-	testCase        string
+	return
 }
 
 // This is the config in string form from the original Configure()
 var expectedConf string = `map[coreSystems:[map[coreSystem:serviceregistrar url:http://localhost:20102/serviceregistrar/registry] map[coreSystem:orchestrator url:http://localhost:20103/orchestrator/orchestration] map[coreSystem:ca url:http://localhost:20100/ca/certification] map[coreSystem:maitreD url:http://localhost:20101/maitreD/maitreD]] protocolsNports:map[coap:0 http:1234 https:0] systemname:testSystem unit_assets:[map[details:map[Test:[Test]] name:testUnitAsset services:[map[costUnit: definition:test details:map[Forms:[SignalA_v1a]] registrationPeriod:45 subpath:test]] traits:<nil>]]]`
 
-// This test is to ensure that setupDefaultConfig() doesnt change the behaviour of of Config()
+type setupDefConfigParams struct {
+	expectError bool
+	testCase    string
+	setup       func(*components.System) (err error)
+	cleanup     func() (err error)
+}
+
 func TestSetupDefaultConfig(t *testing.T) {
+	testParams := []setupDefConfigParams{
+		// {expectError, testCase, setup(), cleanup()}
+		{
+			false,
+			"Best case",
+			func(sys *components.System) (err error) {
+				err = createConfigNoTraits(sys, 1)
+				return err
+			},
+			func() (err error) { return cleanup() },
+		},
+		{
+			false,
+			"Good case, asset has traits",
+			func(sys *components.System) (err error) {
+				err = createConfigHasTraits(sys)
+				return err
+			},
+			func() (err error) { return cleanup() },
+		},
+	}
+
+	// Start of test
+	for _, c := range testParams {
+		testSys := createTestSystem(false)
+
+		// Setup
+		err := c.setup(&testSys)
+		if err != nil {
+			t.Errorf("setup failed: %v", err)
+		}
+
+		// Test
+		_, err = setupDefaultConfig(&testSys)
+		if c.expectError != true {
+			if err != nil {
+				t.Errorf("Expected no errors in testcase '%s', got: %v", c.testCase, err)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("expected errors in testcase '%s', got none", c.testCase)
+			}
+		}
+		// Cleanup
+		err = c.cleanup()
+		if err != nil {
+			t.Errorf("failed to remove 'systemconfig.json' in testcase '%s'", c.testCase)
+		}
+	}
+}
+
+// This test is to ensure that setupDefaultConfig() doesnt change the behaviour of of Config()
+func TestSetupDefaultConfigCorrectness(t *testing.T) {
 	testSys := createTestSystem(false)
 
 	// Setup a default config with setupDefaultConfig() func
@@ -249,41 +296,85 @@ func TestSetupDefaultConfig(t *testing.T) {
 	os.Remove("systemconfig.json")
 
 	// Check if defaultConfig converted to a string is the same as the expectedConf
-	ok := reflect.DeepEqual(fmt.Sprintf("%v", defaultConfig), expectedConf)
-	if ok == false {
+	if fmt.Sprint(defaultConfig) != expectedConf {
 		t.Errorf("systemconfig not equal")
 	}
 }
 
+func cleanup() error {
+	err := os.Remove("systemconfig.json")
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type configureParams struct {
+	expectError bool
+	testCase    string
+	setup       func(*components.System) (err error)
+	cleanup     func() (err error)
+}
+
 func TestConfigure(t *testing.T) {
 	testParams := []configureParams{
-		// {hasTraits, assetNumber, createNewConfig, allowConfigRead, expectError, testCase}
-		{false, 1, true, true, false, "Best case"},
-		{false, 0, false, true, true, "Missing asset"},
-		{true, 0, true, true, false, "Good case, asset has traits"},
-		{false, 1, false, true, true, "Config missing"},
-		{false, 1, false, false, true, "Config missing, cant open or create"},
-		{false, 0, true, true, false, "No Assets in config"},
-		{false, 3, true, true, false, "Multiple Assets in config"},
+		// {expectError, testCase, setup(), cleanup()}
+		{
+			false,
+			"Best case, one asset",
+			func(sys *components.System) (err error) {
+				err = createConfigNoTraits(sys, 1)
+				return
+			},
+			func() (err error) { return cleanup() },
+		},
+		{
+			true,
+			"Can't open/create config",
+			func(sys *components.System) (err error) {
+				_, err = os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0000)
+				return
+			},
+			func() (err error) { return cleanup() },
+		},
+		{
+			true,
+			"Config missing",
+			func(sys *components.System) (err error) { return nil },
+			func() (err error) { return cleanup() },
+		},
+		{
+			false,
+			"No Assets in config",
+			func(sys *components.System) (err error) {
+				err = createConfigNoTraits(sys, 0)
+				return
+			},
+			func() (err error) { return cleanup() },
+		},
+		{
+			false,
+			"Multiple Assets in config",
+			func(sys *components.System) (err error) {
+				err = createConfigNoTraits(sys, 3)
+				return
+			},
+			func() (err error) { return cleanup() },
+		},
 	}
-	defer os.Remove("systemconfig.json")
+
+	// Start of test
 	for _, testCase := range testParams {
 		testSys := createTestSystem(false)
-		os.Remove("systemconfig.json")
-		if testCase.testCase == "Missing asset" {
-			testSys.UAssets = nil
-		}
-		if testCase.createNewConfig == true {
-			if testCase.hasTraits == true {
-				createConfigHasTraits(&testSys)
-			} else {
-				createConfigNoTraits(&testSys, testCase.assetNumber)
-			}
-		}
-		if testCase.allowConfigRead == false {
-			os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0000)
+
+		// Setup
+		err := testCase.setup(&testSys)
+		if err != nil {
+			t.Errorf("failed during setup: %v", err)
 		}
-		_, err := Configure(&testSys)
+
+		// Test
+		_, err = Configure(&testSys)
 		if testCase.expectError == false {
 			if err != nil {
 				t.Errorf("Expected no errors in '%s', got: %v", testCase.testCase, err)
@@ -293,17 +384,11 @@ func TestConfigure(t *testing.T) {
 				t.Errorf("Expected errors in testcase '%s' got none", testCase.testCase)
 			}
 		}
-		if (testCase.createNewConfig == true) || (testCase.allowConfigRead == false) {
-			err = os.Remove("systemconfig.json")
-			if err != nil {
-				t.Fatalf("failed while removing file")
-			}
-		}
-		if errors.Is(err, ErrNewConfig) {
-			err = os.Remove("systemconfig.json")
-			if err != nil {
-				t.Fatalf("failed while removing file")
-			}
+
+		//Cleanup
+		err = testCase.cleanup()
+		if err != nil {
+			t.Errorf("failed to remove 'systemconfig.json' in testcase '%s'", testCase.testCase)
 		}
 	}
 }

From b5ee846efa0ce9f6b455ce21b3b20ac633705ac7 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Wed, 25 Jun 2025 16:13:30 +0200
Subject: [PATCH 075/186] added an error to return in createConfigNoTraits() &
 createConfigHasTraits()

---
 usecases/configuration_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index bc5fc7e..11f53a4 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -116,7 +116,7 @@ func createConfigHasTraits(sys *components.System) (err error) {
 	defaultConfig.Protocols = sys.Husk.ProtoPort
 	defaultConfigFile, err := os.Create("systemconfig.json")
 	if err != nil {
-		return fmt.Errorf("Encountered error while creating default config file")
+		return fmt.Errorf("encountered error while creating default config file: %v", err)
 	}
 	defer defaultConfigFile.Close()
 
@@ -194,7 +194,7 @@ func createConfigNoTraits(sys *components.System, assetAmount int) (err error) {
 	defaultConfig.Protocols = sys.Husk.ProtoPort
 	defaultConfigFile, err := os.Create("systemconfig.json")
 	if err != nil {
-		return fmt.Errorf("Encountered error while creating default config file")
+		return fmt.Errorf("encountered error while creating config file: %v", err)
 	}
 	defer defaultConfigFile.Close()
 

From 3f61cb1da6a2a7be912f189be883ac87359182e2 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Wed, 25 Jun 2025 16:16:46 +0200
Subject: [PATCH 076/186] Added error to return, if error occurs while encoding
 default config in Configure()

---
 usecases/configuration.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index 968e355..53d98a5 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -142,7 +142,7 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 		enc.SetIndent("", "    ")
 		err = enc.Encode(defaultConfig) // Write default values into systemconfig since file was empty
 		if err != nil {
-			return nil, fmt.Errorf("error writing default values to system config")
+			return nil, fmt.Errorf("error writing default values to system config: %v", err)
 		}
 		return nil, ErrNewConfig
 	}

From b6bad99a9899345da6a0c67c39b1ad7a802d977b Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Wed, 25 Jun 2025 16:36:25 +0200
Subject: [PATCH 077/186] fixed PR comments

---
 usecases/configuration.go      |  4 +-
 usecases/configuration_test.go | 83 +++++++++-------------------------
 2 files changed, 23 insertions(+), 64 deletions(-)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index 53d98a5..089c084 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -129,13 +129,13 @@ func Configure(sys *components.System) ([]json.RawMessage, error) {
 	// 0600 allows user Read/Write permission (secure config file), but no R/W for groups and others, 0644 to allow R/W on sudo and only R on groups/others, 0666 for R/W permissions for everyone
 	systemConfigFile, err := os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0600)
 	if err != nil {
-		return nil, fmt.Errorf("error while opening/creating systemconfig file, check permissions on config file")
+		return nil, fmt.Errorf("error while opening/creating systemconfig file: %v", err)
 	}
 	defer systemConfigFile.Close()
 
 	fileInfo, err := systemConfigFile.Stat() // *.Stat() returns fileInfo/stats
 	if err != nil {
-		return nil, fmt.Errorf("error occurred while getting config file stats")
+		return nil, fmt.Errorf("error occurred while getting config file stats: %s", err)
 	}
 	if fileInfo.Size() == 0 { // *.Size() returns the filesize (number bytes) as an int, 0 is an empty file
 		enc := json.NewEncoder(systemConfigFile)
diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index 11f53a4..ea8b145 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -220,24 +220,8 @@ type setupDefConfigParams struct {
 func TestSetupDefaultConfig(t *testing.T) {
 	testParams := []setupDefConfigParams{
 		// {expectError, testCase, setup(), cleanup()}
-		{
-			false,
-			"Best case",
-			func(sys *components.System) (err error) {
-				err = createConfigNoTraits(sys, 1)
-				return err
-			},
-			func() (err error) { return cleanup() },
-		},
-		{
-			false,
-			"Good case, asset has traits",
-			func(sys *components.System) (err error) {
-				err = createConfigHasTraits(sys)
-				return err
-			},
-			func() (err error) { return cleanup() },
-		},
+		{false, "Best case", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 1) }, func() (err error) { return cleanup() }},
+		{false, "Good case, asset has traits", func(sys *components.System) (err error) { return createConfigHasTraits(sys) }, func() (err error) { return cleanup() }},
 	}
 
 	// Start of test
@@ -264,7 +248,7 @@ func TestSetupDefaultConfig(t *testing.T) {
 		// Cleanup
 		err = c.cleanup()
 		if err != nil {
-			t.Errorf("failed to remove 'systemconfig.json' in testcase '%s'", c.testCase)
+			t.Errorf("failed to remove 'systemconfig.json' in testcase '%s': %v", c.testCase, err)
 		}
 	}
 }
@@ -281,20 +265,28 @@ func TestSetupDefaultConfigCorrectness(t *testing.T) {
 
 	def, err := os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0600)
 	if err != nil {
-		t.Errorf("error while opening/creating systemconfig.json in test")
+		t.Errorf("error while opening/creating systemconfig.json in test: %v", err)
 	}
 	defer def.Close()
 	// Write our defaultConfig to file with correct indent
 	enc := json.NewEncoder(def)
 	enc.SetIndent("", "     ")
-	enc.Encode(defConf)
+	err = enc.Encode(defConf)
+	if err != nil {
+		t.Errorf("Couldn't encode to 'systemconfig.json' in test: %v", err)
+	}
 
 	// Decode to defaultConfig so we can compare the created default- and expected config
 	var defaultConfig any
 	def.Seek(0, 0)
-	json.NewDecoder(def).Decode(&defaultConfig)
-	os.Remove("systemconfig.json")
-
+	err = json.NewDecoder(def).Decode(&defaultConfig)
+	if err != nil {
+		t.Errorf("couldn't decode from 'systemconfig.json' in test: %v", err)
+	}
+	err = os.Remove("systemconfig.json")
+	if err != nil {
+		t.Errorf("couldn't remove 'systemconfig.json' in test: %v", err)
+	}
 	// Check if defaultConfig converted to a string is the same as the expectedConf
 	if fmt.Sprint(defaultConfig) != expectedConf {
 		t.Errorf("systemconfig not equal")
@@ -302,11 +294,7 @@ func TestSetupDefaultConfigCorrectness(t *testing.T) {
 }
 
 func cleanup() error {
-	err := os.Remove("systemconfig.json")
-	if err != nil {
-		return err
-	}
-	return nil
+	return os.Remove("systemconfig.json")
 }
 
 type configureParams struct {
@@ -319,15 +307,7 @@ type configureParams struct {
 func TestConfigure(t *testing.T) {
 	testParams := []configureParams{
 		// {expectError, testCase, setup(), cleanup()}
-		{
-			false,
-			"Best case, one asset",
-			func(sys *components.System) (err error) {
-				err = createConfigNoTraits(sys, 1)
-				return
-			},
-			func() (err error) { return cleanup() },
-		},
+		{false, "Best case, one asset", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 1) }, func() (err error) { return cleanup() }},
 		{
 			true,
 			"Can't open/create config",
@@ -337,30 +317,9 @@ func TestConfigure(t *testing.T) {
 			},
 			func() (err error) { return cleanup() },
 		},
-		{
-			true,
-			"Config missing",
-			func(sys *components.System) (err error) { return nil },
-			func() (err error) { return cleanup() },
-		},
-		{
-			false,
-			"No Assets in config",
-			func(sys *components.System) (err error) {
-				err = createConfigNoTraits(sys, 0)
-				return
-			},
-			func() (err error) { return cleanup() },
-		},
-		{
-			false,
-			"Multiple Assets in config",
-			func(sys *components.System) (err error) {
-				err = createConfigNoTraits(sys, 3)
-				return
-			},
-			func() (err error) { return cleanup() },
-		},
+		{true, "Config missing", func(sys *components.System) (err error) { return nil }, func() (err error) { return cleanup() }},
+		{false, "No Assets in config", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 0) }, func() (err error) { return cleanup() }},
+		{false, "Multiple Assets in config", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 3) }, func() (err error) { return cleanup() }},
 	}
 
 	// Start of test

From 0f93479d7fdc1e2b8ac7880fef74adefd8a38638 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 26 Jun 2025 14:12:57 +0200
Subject: [PATCH 078/186] Added back makeServiceMap() and its tests, and
 finished PR comments

---
 usecases/configuration.go      | 11 ++++++++++
 usecases/configuration_test.go | 39 ++++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+)

diff --git a/usecases/configuration.go b/usecases/configuration.go
index 089c084..e623df7 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -185,3 +185,14 @@ func getServicesList(uat components.UnitAsset) []components.Service {
 	}
 	return serviceList
 }
+
+// MakeServiceMap() creates a map of services from a slice of services
+// The map is indexed by the service subpath
+func MakeServiceMap(services []components.Service) map[string]*components.Service {
+	serviceMap := make(map[string]*components.Service)
+	for i := range services {
+		svc := services[i] // take the address of the element in the slice
+		serviceMap[svc.SubPath] = &svc
+	}
+	return serviceMap
+}
diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index ea8b145..7620746 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -222,6 +222,7 @@ func TestSetupDefaultConfig(t *testing.T) {
 		// {expectError, testCase, setup(), cleanup()}
 		{false, "Best case", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 1) }, func() (err error) { return cleanup() }},
 		{false, "Good case, asset has traits", func(sys *components.System) (err error) { return createConfigHasTraits(sys) }, func() (err error) { return cleanup() }},
+		{true, "No assets in sys", func(sys *components.System) (err error) { return createConfigHasTraits(sys) }, func() (err error) { return cleanup() }},
 	}
 
 	// Start of test
@@ -234,6 +235,10 @@ func TestSetupDefaultConfig(t *testing.T) {
 			t.Errorf("setup failed: %v", err)
 		}
 
+		if c.testCase == "No assets in sys" {
+			testSys.UAssets = nil
+		}
+
 		// Test
 		_, err = setupDefaultConfig(&testSys)
 		if c.expectError != true {
@@ -245,6 +250,7 @@ func TestSetupDefaultConfig(t *testing.T) {
 				t.Errorf("expected errors in testcase '%s', got none", c.testCase)
 			}
 		}
+
 		// Cleanup
 		err = c.cleanup()
 		if err != nil {
@@ -320,6 +326,15 @@ func TestConfigure(t *testing.T) {
 		{true, "Config missing", func(sys *components.System) (err error) { return nil }, func() (err error) { return cleanup() }},
 		{false, "No Assets in config", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 0) }, func() (err error) { return cleanup() }},
 		{false, "Multiple Assets in config", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 3) }, func() (err error) { return cleanup() }},
+		{
+			true,
+			"No assets in sys",
+			func(sys *components.System) (err error) {
+				sys.UAssets = nil
+				return createConfigNoTraits(sys, 1)
+			},
+			func() (err error) { return cleanup() },
+		},
 	}
 
 	// Start of test
@@ -377,3 +392,27 @@ func TestGetServiceList(t *testing.T) {
 		t.Errorf("Expected length: 1, got %d\tExpected 'Definition': test, got %s", len(servList), servList[0].Definition)
 	}
 }
+
+func TestMakeServiceMap(t *testing.T) {
+	var servList []components.Service
+	for x := range 6 {
+		serv := components.Service{
+			ID:            x,
+			Definition:    fmt.Sprintf("testDef%d", x),
+			SubPath:       fmt.Sprintf("test%d", x),
+			Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+			Description:   fmt.Sprintf("test service %d", x),
+			RegPeriod:     45,
+			RegTimestamp:  "now",
+			RegExpiration: "45",
+		}
+		servList = append(servList, serv)
+	}
+	servMap := MakeServiceMap(servList)
+	for c := range 6 {
+		service := fmt.Sprintf("test%d", c)
+		if servMap[service].SubPath != service || servMap[service].ID != c {
+			t.Errorf(`Expected servMap["%s"].SubPath to be "%s", with ID: "%d". Got Subpath: "%s", with ID: "%d"`, service, service, c, servMap[service].SubPath, servMap[service].ID)
+		}
+	}
+}

From c1649336c0d56f39f7f5c0f1b8fbdac6097869b3 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Wed, 25 Jun 2025 13:23:18 +0200
Subject: [PATCH 079/186] Made tests for components/service.go

---
 components/service_test.go | 195 +++++++++++++++++++++++++++++++++++++
 1 file changed, 195 insertions(+)
 create mode 100644 components/service_test.go

diff --git a/components/service_test.go b/components/service_test.go
new file mode 100644
index 0000000..0125a09
--- /dev/null
+++ b/components/service_test.go
@@ -0,0 +1,195 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Synecdoque
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, subject to the following conditions:
+ *
+ * The software is licensed under the MIT License. See the LICENSE file in this repository for details.
+ *
+ * Contributors:
+ *   Jan A. van Deventer, Luleå - initial implementation
+ *   Thomas Hedeler, Hamburg - initial implementation
+ ***************************************************************************SDG*/
+
+package components
+
+import (
+	"reflect"
+	"testing"
+)
+
+type mergeDetailsTestStruct struct {
+	map1     map[string][]string
+	map2     map[string][]string
+	expected map[string][]string
+}
+
+var testService = Service{
+	ID:            1,
+	Definition:    "test",
+	SubPath:       "testSubPath",
+	Details:       make(map[string][]string),
+	RegPeriod:     45,
+	RegTimestamp:  "",
+	RegExpiration: "",
+	Description:   "A test service",
+	SubscribeAble: false,
+	ACost:         0,
+	CUnit:         "",
+}
+
+var testOriginalService = Service{
+	ID:            1,
+	Definition:    "original one",
+	SubPath:       "testOriginalSubPath",
+	Details:       map[string][]string{"test": {"test1", "test2"}},
+	RegPeriod:     45,
+	RegTimestamp:  "",
+	RegExpiration: "",
+	Description:   "A test original service",
+	SubscribeAble: false,
+	ACost:         0,
+	CUnit:         "",
+}
+
+var testServiceWithEmptyDetails = Service{
+	ID:            1,
+	Definition:    "original one",
+	SubPath:       "testOriginalSubPath",
+	Details:       make(map[string][]string),
+	RegPeriod:     45,
+	RegTimestamp:  "",
+	RegExpiration: "",
+	Description:   "A test original service",
+	SubscribeAble: false,
+	ACost:         0,
+	CUnit:         "",
+}
+
+func makeNewTestService(id int, definition string) *Service {
+	return &Service{
+		ID:            id,
+		Definition:    definition,
+		SubPath:       "newTestServiceSubPath",
+		Details:       make(map[string][]string),
+		RegPeriod:     45,
+		RegTimestamp:  "",
+		RegExpiration: "",
+		Description:   "A new test Service",
+		SubscribeAble: false,
+		ACost:         0,
+		CUnit:         "",
+	}
+}
+
+func makeNewMap(key string, value string) map[string][]string {
+	newMap := map[string][]string{
+		key: {value},
+	}
+	return newMap
+}
+
+var expectedRegularMerge = map[string][]string{
+	"a": {"1"},
+	"b": {"2"},
+}
+
+var expectedKeyOverlapMerge = map[string][]string{
+	"a": {"1", "3"},
+}
+
+var expectedOneEmptyMapMerge = map[string][]string{
+	"a": {"1"},
+}
+
+var expectedBothEmptyMapMerge = map[string][]string{}
+
+var mergeDetailsTestParams = []mergeDetailsTestStruct{
+	{makeNewMap("a", "1"), makeNewMap("b", "2"), expectedRegularMerge},
+	{makeNewMap("a", "1"), makeNewMap("a", "3"), expectedKeyOverlapMerge},
+	{makeNewMap("a", "1"), make(map[string][]string), expectedOneEmptyMapMerge},
+	{make(map[string][]string), make(map[string][]string), expectedBothEmptyMapMerge},
+}
+
+func TestMerge(t *testing.T) {
+	testService.Merge(&testOriginalService)
+	if testService.Definition != testOriginalService.Definition ||
+		testService.SubPath != testOriginalService.SubPath ||
+		testService.Description != testOriginalService.Description {
+		t.Errorf("Expected the test service to be the same as the original test service %s, got: %s", testOriginalService.Definition, testService.Definition)
+	}
+}
+
+func TestDeepCopy(t *testing.T) {
+	res := testOriginalService.DeepCopy()
+	res.Details["test"][0] = "changed"
+	res.Details["newkey"] = []string{"newTest"}
+
+	if testOriginalService.Details["test"][0] == "changed" {
+		t.Errorf("DeepCopy failed, expected original slice to remain, original slice was mutated")
+	}
+	if _, ok := testOriginalService.Details["newkey"]; ok {
+		t.Errorf("DeepCopy failed, expected no new key in original, got %s", testOriginalService.Details["newkey"])
+	}
+
+	res = testServiceWithEmptyDetails.DeepCopy()
+	if len(res.Details) != 0 {
+		t.Errorf("DeepCopy failed, expected details map to be empty after copy, got: %v", res.Details)
+	}
+}
+
+func TestCloneServices(t *testing.T) {
+	test1 := makeNewTestService(1, "test")
+	test2 := makeNewTestService(2, "test")
+
+	cloned := CloneServices([]Service{*test1, *test2})
+	if len(cloned) != 1 {
+		t.Errorf("Expected 1 Service, got %d", len(cloned))
+	}
+	if cloned["test"].ID != 2 {
+		t.Errorf("Second Service did not overwrite the first as expected")
+	}
+
+	cloned["test"].ID = 3
+	if test1.ID == 3 || test2.ID == 3 {
+		t.Errorf("DeepCopy failed: mutation of clone affected either one of the originals")
+	}
+
+	cloned = CloneServices(nil)
+	if cloned == nil {
+		t.Errorf("Expected non-nil empty map for nil input")
+	}
+	if len(cloned) != 0 {
+		t.Errorf("Expected 0 Services, got %d", len(cloned))
+	}
+
+	test1 = makeNewTestService(1, "")
+	test2 = makeNewTestService(2, "")
+
+	cloned = CloneServices([]Service{*test1, *test2})
+
+	if len(cloned) != 1 {
+		t.Errorf("Expected 1 entry, got %d", len(cloned))
+	}
+}
+
+func TestMergeDetails(t *testing.T) {
+	for _, test := range mergeDetailsTestParams {
+		merged := MergeDetails(test.map1, test.map2)
+
+		if !reflect.DeepEqual(merged, test.expected) {
+			t.Errorf("Expected %v, got %v", test.expected, merged)
+		}
+
+		if len(merged) != 0 {
+			merged["a"][0] = "changed"
+
+			if reflect.DeepEqual(merged, test.map1) || reflect.DeepEqual(merged, test.map2) {
+				t.Errorf("A change in the merged map resulted in a change in the input maps")
+			}
+		}
+	}
+}

From aeee240001c44aafec678cb8721ee4ae4ddc5660 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Wed, 25 Jun 2025 16:02:55 +0200
Subject: [PATCH 080/186] Updated the tests for components/service.go to not
 use reflect

---
 components/service_test.go | 39 ++++++++++++++++++++++++++++++++++----
 1 file changed, 35 insertions(+), 4 deletions(-)

diff --git a/components/service_test.go b/components/service_test.go
index 0125a09..6e4aa71 100644
--- a/components/service_test.go
+++ b/components/service_test.go
@@ -17,7 +17,7 @@
 package components
 
 import (
-	"reflect"
+	"fmt"
 	"testing"
 )
 
@@ -114,6 +114,33 @@ var mergeDetailsTestParams = []mergeDetailsTestStruct{
 	{make(map[string][]string), make(map[string][]string), expectedBothEmptyMapMerge},
 }
 
+func manualEqualityCheck(map1 map[string][]string, map2 map[string][]string) error {
+	if len(map1) != len(map2) {
+		return fmt.Errorf("Expected map length %d, got %d", len(map2), len(map1))
+	} else {
+		for k, v := range map2 {
+			mv, ok := map1[k]
+			if !ok {
+				return fmt.Errorf("Expected key %q not found in merged map", k)
+			}
+			if len(mv) != len(v) {
+				return fmt.Errorf("For key %q, expected slice length %d, got %d", k, len(v), len(mv))
+			}
+			for i := range v {
+				if mv[i] != v[i] {
+					return fmt.Errorf("For key %q, at index %d, expected %q, got %q", k, i, v[i], mv[i])
+				}
+			}
+		}
+		for k := range map1 {
+			if _, ok := map2[k]; !ok {
+				return fmt.Errorf("Unexpected key %q found in merged map", k)
+			}
+		}
+	}
+	return nil
+}
+
 func TestMerge(t *testing.T) {
 	testService.Merge(&testOriginalService)
 	if testService.Definition != testOriginalService.Definition ||
@@ -180,16 +207,20 @@ func TestMergeDetails(t *testing.T) {
 	for _, test := range mergeDetailsTestParams {
 		merged := MergeDetails(test.map1, test.map2)
 
-		if !reflect.DeepEqual(merged, test.expected) {
+		err := manualEqualityCheck(merged, test.expected)
+		if err != nil {
 			t.Errorf("Expected %v, got %v", test.expected, merged)
 		}
 
 		if len(merged) != 0 {
 			merged["a"][0] = "changed"
 
-			if reflect.DeepEqual(merged, test.map1) || reflect.DeepEqual(merged, test.map2) {
-				t.Errorf("A change in the merged map resulted in a change in the input maps")
+			err1 := manualEqualityCheck(merged, test.map1)
+			err2 := manualEqualityCheck(merged, test.map2)
+			if err1 != nil || err2 != nil {
+				continue // The two maps should not be equal so if we get an "error" the test case has passed
 			}
+			t.Errorf("A change in the merged map resulted in a change in the input maps")
 		}
 	}
 }

From b68a1c18dbeb9e1672ae9fc4ad71ec2e05bebb69 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Thu, 26 Jun 2025 14:40:06 +0200
Subject: [PATCH 081/186] Added tests for components/host.go and
 components/husk.go also

---
 components/host_test.go | 86 +++++++++++++++++++++++++++++++++++++++++
 components/husk_test.go | 38 ++++++++++++++++++
 2 files changed, 124 insertions(+)
 create mode 100644 components/host_test.go
 create mode 100644 components/husk_test.go

diff --git a/components/host_test.go b/components/host_test.go
new file mode 100644
index 0000000..1627e7e
--- /dev/null
+++ b/components/host_test.go
@@ -0,0 +1,86 @@
+package components
+
+import (
+	"os"
+	"testing"
+)
+
+type hostnameTestStruct struct {
+	expectedHostname string
+	expectedErr      error
+}
+
+type ipAddressesTestStruct struct {
+	expectedErr error
+}
+
+type macAddressesTestStruct struct {
+	expectedErr error
+}
+
+type newDeviceTestStruct struct {
+	expectedDevice *HostingDevice
+}
+
+var hostname, _ = os.Hostname()
+
+var hostnameTestParams = []hostnameTestStruct{
+	{hostname, nil},
+}
+
+var ipAddressesTestParams = []ipAddressesTestStruct{
+	{nil},
+}
+
+var macAddressesTestParams = []macAddressesTestStruct{
+	{nil},
+}
+
+var newDeviceTestParams = []newDeviceTestStruct{
+	{createTestDevice()},
+}
+
+func createTestDevice() *HostingDevice {
+	return NewDevice()
+}
+
+func TestHostname(t *testing.T) {
+	for _, testCase := range hostnameTestParams {
+		res, err := Hostname()
+
+		if res != testCase.expectedHostname || err != testCase.expectedErr {
+			t.Errorf("Expected %s and %v, got: %s and %v", testCase.expectedHostname, testCase.expectedErr, res, err)
+		}
+	}
+}
+
+func TestIpAddresses(t *testing.T) {
+	for _, testCase := range ipAddressesTestParams {
+		res, err := IpAddresses()
+
+		if len(res) == 0 || err != testCase.expectedErr {
+			t.Errorf("Expected %v, got: %s and %v", testCase.expectedErr, res, err)
+		}
+	}
+}
+
+func TestMacAddresses(t *testing.T) {
+	for _, testCase := range macAddressesTestParams {
+		ip, err := IpAddresses()
+		res, err := MacAddresses(ip)
+
+		if len(res) == 0 || err != testCase.expectedErr {
+			t.Errorf("Expected error %v, got: %s and %v", testCase.expectedErr, res, err)
+		}
+	}
+}
+
+func TestNewDevice(t *testing.T) {
+	for _, testCase := range newDeviceTestParams {
+		res := NewDevice()
+
+		if res.Name != testCase.expectedDevice.Name || len(res.IPAddresses) != len(testCase.expectedDevice.IPAddresses) || len(res.MACAddresses) != len(testCase.expectedDevice.MACAddresses) {
+			t.Errorf("Expected %s, %v, %v, got: %s, %v, %v", testCase.expectedDevice.Name, testCase.expectedDevice.IPAddresses, testCase.expectedDevice.MACAddresses, res.Name, res.IPAddresses, res.MACAddresses)
+		}
+	}
+}
diff --git a/components/husk_test.go b/components/husk_test.go
new file mode 100644
index 0000000..9364b53
--- /dev/null
+++ b/components/husk_test.go
@@ -0,0 +1,38 @@
+package components
+
+import (
+	"testing"
+)
+
+type sProtocolsTestStruct struct {
+	input          map[string]int
+	expectedOutput []string
+}
+
+var sProtocolsTestParams = []sProtocolsTestStruct{
+	{makeEmptyProtoPortMap(), nil},
+	{makeProtoPortMapWithPortZero(), nil},
+	{makeFullProtoPortMap(), []string{"Port1", "Port2"}},
+}
+
+func makeEmptyProtoPortMap() map[string]int {
+	return make(map[string]int)
+}
+
+func makeProtoPortMapWithPortZero() map[string]int {
+	return map[string]int{"Port": 0}
+}
+
+func makeFullProtoPortMap() map[string]int {
+	return map[string]int{"Port1": 123, "Port2": 404, "Port3": 0}
+}
+
+func TestSProtocols(t *testing.T) {
+	for _, testCase := range sProtocolsTestParams {
+		res := SProtocols(testCase.input)
+
+		if len(res) != len(testCase.expectedOutput) {
+			t.Errorf("Expected %v, got: %v", testCase.expectedOutput, res)
+		}
+	}
+}

From f2109b7caec212ac637b9fe30d4497524a50a8c1 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Fri, 27 Jun 2025 13:12:52 +0200
Subject: [PATCH 082/186] Fixed PR comments

---
 components/host_test.go    | 77 ++++++++------------------------------
 components/service_test.go | 49 ++++++++----------------
 2 files changed, 32 insertions(+), 94 deletions(-)

diff --git a/components/host_test.go b/components/host_test.go
index 1627e7e..5dbe78d 100644
--- a/components/host_test.go
+++ b/components/host_test.go
@@ -1,86 +1,41 @@
 package components
 
 import (
-	"os"
 	"testing"
 )
 
-type hostnameTestStruct struct {
-	expectedHostname string
-	expectedErr      error
-}
-
-type ipAddressesTestStruct struct {
-	expectedErr error
-}
-
-type macAddressesTestStruct struct {
-	expectedErr error
-}
-
-type newDeviceTestStruct struct {
-	expectedDevice *HostingDevice
-}
-
-var hostname, _ = os.Hostname()
-
-var hostnameTestParams = []hostnameTestStruct{
-	{hostname, nil},
-}
-
-var ipAddressesTestParams = []ipAddressesTestStruct{
-	{nil},
-}
-
-var macAddressesTestParams = []macAddressesTestStruct{
-	{nil},
-}
-
-var newDeviceTestParams = []newDeviceTestStruct{
-	{createTestDevice()},
-}
-
-func createTestDevice() *HostingDevice {
-	return NewDevice()
-}
-
 func TestHostname(t *testing.T) {
-	for _, testCase := range hostnameTestParams {
-		res, err := Hostname()
+	res, err := Hostname()
 
-		if res != testCase.expectedHostname || err != testCase.expectedErr {
-			t.Errorf("Expected %s and %v, got: %s and %v", testCase.expectedHostname, testCase.expectedErr, res, err)
-		}
+	if res == "" || err != nil {
+		t.Errorf("Expected a host name and no error, got: %s and %v", res, err)
 	}
 }
 
 func TestIpAddresses(t *testing.T) {
-	for _, testCase := range ipAddressesTestParams {
-		res, err := IpAddresses()
+	res, err := IpAddresses()
 
-		if len(res) == 0 || err != testCase.expectedErr {
-			t.Errorf("Expected %v, got: %s and %v", testCase.expectedErr, res, err)
-		}
+	if len(res) == 0 || err != nil {
+		t.Errorf("Expected IP addresses and no error, got: %s and %v", res, err)
 	}
 }
 
 func TestMacAddresses(t *testing.T) {
-	for _, testCase := range macAddressesTestParams {
-		ip, err := IpAddresses()
-		res, err := MacAddresses(ip)
+	ip, err := IpAddresses()
+	if err != nil {
+		t.Fatalf("An error occurred in getting IP Addresses for the Mac Address test")
+	}
+	res, err := MacAddresses(ip)
 
-		if len(res) == 0 || err != testCase.expectedErr {
-			t.Errorf("Expected error %v, got: %s and %v", testCase.expectedErr, res, err)
-		}
+	if len(res) == 0 || err != nil {
+		t.Errorf("Expected no error, got: %s and %v", res, err)
 	}
 }
 
 func TestNewDevice(t *testing.T) {
-	for _, testCase := range newDeviceTestParams {
-		res := NewDevice()
+	res := NewDevice()
 
-		if res.Name != testCase.expectedDevice.Name || len(res.IPAddresses) != len(testCase.expectedDevice.IPAddresses) || len(res.MACAddresses) != len(testCase.expectedDevice.MACAddresses) {
-			t.Errorf("Expected %s, %v, %v, got: %s, %v, %v", testCase.expectedDevice.Name, testCase.expectedDevice.IPAddresses, testCase.expectedDevice.MACAddresses, res.Name, res.IPAddresses, res.MACAddresses)
-		}
+	if res == nil {
+		t.Errorf("Expected a new device, got: %v", res)
 	}
 }
diff --git a/components/service_test.go b/components/service_test.go
index 6e4aa71..1984b4e 100644
--- a/components/service_test.go
+++ b/components/service_test.go
@@ -1,19 +1,3 @@
-/*******************************************************************************
- * Copyright (c) 2025 Synecdoque
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, subject to the following conditions:
- *
- * The software is licensed under the MIT License. See the LICENSE file in this repository for details.
- *
- * Contributors:
- *   Jan A. van Deventer, Luleå - initial implementation
- *   Thomas Hedeler, Hamburg - initial implementation
- ***************************************************************************SDG*/
-
 package components
 
 import (
@@ -117,27 +101,26 @@ var mergeDetailsTestParams = []mergeDetailsTestStruct{
 func manualEqualityCheck(map1 map[string][]string, map2 map[string][]string) error {
 	if len(map1) != len(map2) {
 		return fmt.Errorf("Expected map length %d, got %d", len(map2), len(map1))
-	} else {
-		for k, v := range map2 {
-			mv, ok := map1[k]
-			if !ok {
-				return fmt.Errorf("Expected key %q not found in merged map", k)
-			}
-			if len(mv) != len(v) {
-				return fmt.Errorf("For key %q, expected slice length %d, got %d", k, len(v), len(mv))
-			}
-			for i := range v {
-				if mv[i] != v[i] {
-					return fmt.Errorf("For key %q, at index %d, expected %q, got %q", k, i, v[i], mv[i])
-				}
-			}
+	}
+	for key, value := range map2 {
+		mv, ok := map1[key]
+		if !ok {
+			return fmt.Errorf("Expected key %q not found in merged map", key)
+		}
+		if len(mv) != len(value) {
+			return fmt.Errorf("For key %q, expected slice length %d, got %d", key, len(value), len(mv))
 		}
-		for k := range map1 {
-			if _, ok := map2[k]; !ok {
-				return fmt.Errorf("Unexpected key %q found in merged map", k)
+		for i := range value {
+			if mv[i] != value[i] {
+				return fmt.Errorf("For key %q, at index %d, expected %q, got %q", key, i, value[i], mv[i])
 			}
 		}
 	}
+	for key := range map1 {
+		if _, ok := map2[key]; !ok {
+			return fmt.Errorf("Unexpected key %q found in merged map", key)
+		}
+	}
 	return nil
 }
 

From f41b46984157bb6411e0fbab97b099144ed34836 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Wed, 25 Jun 2025 14:12:15 +0200
Subject: [PATCH 083/186] Added test for Pack()

---
 usecases/utilities_test.go | 159 +++++++++++++++++++++++++++++++++++++
 1 file changed, 159 insertions(+)
 create mode 100644 usecases/utilities_test.go

diff --git a/usecases/utilities_test.go b/usecases/utilities_test.go
new file mode 100644
index 0000000..73cd618
--- /dev/null
+++ b/usecases/utilities_test.go
@@ -0,0 +1,159 @@
+package usecases
+
+import (
+	"encoding/xml"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/sdoque/mbaigo/forms"
+)
+
+type mockForm struct {
+	XMLName xml.Name `json:"-" xml:"testName"`
+	Value   float64  `json:"value" xml:"value"`
+	Unit    string   `json:"unit" xml:"unit"`
+	Version string   `json:"version" xml:"version"`
+}
+
+// NewForm creates a new form
+func (f mockForm) NewForm() forms.Form {
+	f.Version = "testVersion"
+	return f
+}
+
+// FormVersion returns the version of the form
+func (f mockForm) FormVersion() string {
+	return f.Version
+}
+
+// Returns a form containing test values
+func createTestForm() (f mockForm) {
+	form := mockForm{
+		XMLName: xml.Name{},
+		Value:   123,
+		Unit:    "testUnit",
+		Version: "testVersion",
+	}
+	return form
+}
+
+type brokenMockForm struct {
+	XMLName xml.Name  `json:"-" xml:"testName"`
+	Value   complex64 `json:"value" xml:"value"`
+	Unit    string    `json:"unit" xml:"unit"`
+	Version string    `json:"version" xml:"version"`
+}
+
+// NewForm creates a new form
+func (f brokenMockForm) NewForm() forms.Form {
+	f.Version = "testVersion"
+	return f
+}
+
+// FormVersion returns the version of the form
+func (f brokenMockForm) FormVersion() string {
+	return f.Version
+}
+
+// Returns a form containing complex numbers, which xml and json can't marshal
+func createBrokenTestForm() (f brokenMockForm) {
+	form := brokenMockForm{
+		XMLName: xml.Name{},
+		Value:   complex(1, 2),
+		Unit:    "testUnit",
+		Version: "testVersion",
+	}
+	return form
+}
+
+type packParams struct {
+	contentType   string
+	form          forms.Form
+	expectedError bool
+	testCase      string
+}
+
+// Returns an error containing a list values who was missing/wrong
+func assurePackData(byteArr []byte, contentType string, expectedError bool) (err error) {
+	data := string(byteArr)
+	if contentType == "application/xml" {
+		missingData := []string{}
+		correctName := strings.Contains(data, "<testName>")
+		if correctName != true {
+			missingData = append(missingData, "XMLName")
+		}
+		if expectedError == false {
+			correctValue := strings.Contains(data, "<value>123</value>")
+			if correctValue != true {
+				missingData = append(missingData, "Value")
+			}
+		} else {
+			correctValue := strings.Contains(data, "<value>(1+2i)</value>")
+			if correctValue != true {
+				missingData = append(missingData, "Value")
+			}
+		}
+		correctUnit := strings.Contains(data, "<unit>testUnit</unit>")
+		if correctUnit != true {
+			missingData = append(missingData, "Unit")
+		}
+		correctVersion := strings.Contains(data, "<version>testVersion</version>")
+		if correctVersion != true {
+			missingData = append(missingData, "Version")
+		}
+		if len(missingData) != 0 {
+			return fmt.Errorf("missing data: %s", missingData)
+		}
+	} else {
+		missingData := []string{}
+		if expectedError == false {
+			correctValue := strings.Contains(data, `"value": 123`)
+			if correctValue != true {
+				missingData = append(missingData, "Value")
+			}
+		} else {
+			correctValue := strings.Contains(data, `"value": (1+2i)`)
+			if correctValue != true {
+				missingData = append(missingData, "Value")
+			}
+		}
+		correctUnit := strings.Contains(data, `"unit": "testUnit"`)
+		if correctUnit != true {
+			missingData = append(missingData, "Unit")
+		}
+		correctVersion := strings.Contains(data, `"version": "testVersion"`)
+		if correctVersion != true {
+			missingData = append(missingData, "Version")
+		}
+		if len(missingData) != 0 {
+			return fmt.Errorf("missing data: %s", missingData)
+		}
+	}
+	return nil
+}
+
+func TestPack(t *testing.T) {
+	params := []packParams{
+		{"application/xml", createTestForm(), false, "Best case, xml"},
+		{"application/json", createTestForm(), false, "Best case, json"},
+		{"application/xml", createBrokenTestForm(), true, "Bad case, xml"},
+		{"application/json", createBrokenTestForm(), true, "Bad case, json"},
+	}
+	for _, c := range params {
+		data, err := Pack(c.form, c.contentType)
+		if c.expectedError == false {
+			if err != nil {
+				t.Errorf("failed in testcase '%s' with error: %v", c.testCase, err)
+			}
+			err = assurePackData(data, c.contentType, c.expectedError)
+			if err != nil {
+				t.Errorf("error from assureData: %v", err)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("expected error in testcase '%s', got none", c.testCase)
+			}
+		}
+	}
+}

From e0aed63b27c5b6ac20aaed30d823098b4c93699b Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 26 Jun 2025 17:49:30 +0200
Subject: [PATCH 084/186] Added tests for Unpack() and naming convention tools.
 Moved prints in error handlers into return as errors

---
 usecases/utilities.go      |  30 +++--
 usecases/utilities_test.go | 218 +++++++++++++++++++++++++++++++++++++
 2 files changed, 231 insertions(+), 17 deletions(-)

diff --git a/usecases/utilities.go b/usecases/utilities.go
index 3825f95..2d97e52 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -23,9 +23,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"encoding/xml"
-	"errors"
 	"fmt"
-	"log"
 	"reflect"
 	"strings"
 	"unicode"
@@ -62,16 +60,16 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 		if len(trimmed) > 0 {
 			switch trimmed[0] {
 			case '{', '[':
-				log.Println("Detected JSON in text/plain payload.")
+				//log.Println("Detected JSON in text/plain payload.")
 				contentType = "application/json"
 			case '<':
-				log.Println("Detected XML in text/plain payload.")
+				//log.Println("Detected XML in text/plain payload.")
 				contentType = "application/xml"
 			default:
-				return nil, errors.New("plain text content is neither valid JSON nor XML")
+				return nil, fmt.Errorf("plain text content is neither valid JSON nor XML")
 			}
 		} else {
-			return nil, errors.New("empty payload with content type text/plain")
+			return nil, fmt.Errorf("empty payload with content type text/plain")
 		}
 	}
 
@@ -79,28 +77,28 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, &rawData); err != nil {
-			log.Printf("Error unmarshalling JSON: %v", err)
-			return nil, err
+			//log.Printf("Error unmarshalling JSON: %v", err)
+			return nil, fmt.Errorf("error unmarshalling JSON: %v", err)
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, &rawData); err != nil {
-			log.Printf("Error unmarshalling XML: %v", err)
-			return nil, err
+			//log.Printf("Error unmarshalling XML: %v", err)
+			return nil, fmt.Errorf("error unmarshalling XML: %v", err)
 		}
 	default:
-		return nil, errors.New("unsupported content type")
+		return nil, fmt.Errorf("unsupported content type")
 	}
 
 	// Retrieve form version
 	formVersion, ok := rawData["version"].(string)
 	if !ok {
-		return nil, errors.New("'version' key not found in data")
+		return nil, fmt.Errorf("'version' key not found in data")
 	}
 
 	// Look up the form type in the map
 	formType, exists := forms.FormTypeMap[formVersion]
 	if !exists {
-		return nil, errors.New("unsupported form version: " + formVersion)
+		return nil, fmt.Errorf("unsupported form version: " + formVersion)
 	}
 
 	// Create a new instance of the form
@@ -110,13 +108,11 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, formInstance); err != nil {
-			log.Printf("Error unmarshalling JSON into form: %v", err)
-			return nil, err
+			return nil, fmt.Errorf("error unmarshalling JSON into form: %v", err)
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, formInstance); err != nil {
-			log.Printf("Error unmarshalling XML into form: %v", err)
-			return nil, err
+			return nil, fmt.Errorf("error unmarshalling XML into form: %v", err)
 		}
 	}
 
diff --git a/usecases/utilities_test.go b/usecases/utilities_test.go
index 73cd618..111bddf 100644
--- a/usecases/utilities_test.go
+++ b/usecases/utilities_test.go
@@ -1,8 +1,10 @@
 package usecases
 
 import (
+	"encoding/json"
 	"encoding/xml"
 	"fmt"
+	"math"
 	"strings"
 	"testing"
 
@@ -157,3 +159,219 @@ func TestPack(t *testing.T) {
 		}
 	}
 }
+
+// This covers the case of it having a version but is not present in the form type map
+type testFormHasVersion struct {
+	Name    string `json:"name"`
+	Version string `json:"version"`
+}
+
+// This covers the case of it not having a version
+type testFormNoVersion struct {
+	Name string `json:"name"`
+}
+
+type unpackParams struct {
+	expectError bool
+	testCase    string
+	contentType string
+	setup       func() (data []byte, err error)
+}
+
+func TestUnpack(t *testing.T) {
+	testParams := []unpackParams{
+		//{expectError, testCase, contentType, setup()}
+		{false, "Best case, json", "text/plain", func() (data []byte, err error) {
+			var f forms.SignalA_v1a
+			f.NewForm()
+			data, err = json.Marshal(f)
+			return
+		}},
+		/* {false, "Best case, xml", "text/plain", func() (data []byte, err error) {
+			var f forms.SignalA_v1a
+			f.NewForm()
+			data, err = xml.Marshal(f)
+			return
+		}}, */
+		{true, "Bad case, not json/xml", "text/plain", func() (data []byte, err error) { return []byte("TEST123"), nil }},
+		{true, "Bad case, empty []byte", "text/plain", func() (data []byte, err error) { return []byte(""), nil }},
+		{true, "Bad case, unsupported content type", "unknown", func() (data []byte, err error) { return []byte("test"), nil }},
+		{true, "Bad case, missing version", "application/json", func() (data []byte, err error) {
+			f := &testFormNoVersion{
+				Name: "testName",
+			}
+			data, err = json.Marshal(f)
+			return data, err
+		}},
+		{true, "Bad case, unsupported form version", "application/json", func() (data []byte, err error) {
+			f := &testFormHasVersion{
+				Name:    "testName",
+				Version: "testVersion",
+			}
+			data, err = json.Marshal(f)
+			return data, err
+		}},
+		{true, "Bad case, broken unmarshal in json", "application/json", func() (data []byte, err error) {
+			data = append(data, byte(math.NaN()))
+			return data, err
+		}},
+		// Can't reach second unmarshal for json to break it this way, moving on.
+		/* {true, "Bad case, broken unmarshal in xml", "application/xml", func() (data []byte, err error) {
+			data = append(data, byte(math.NaN()))
+			return data, err
+		}}, */
+		// Can't reach second unmarshal for xml to break it this way, moving on.
+	}
+
+	for _, c := range testParams {
+		// Setup
+		data, err := c.setup()
+		if err != nil {
+			t.Errorf("unexpected error in setup of testcase '%s': %v", c.testCase, err)
+		}
+
+		// Test
+		_, err = Unpack(data, c.contentType)
+		if c.expectError != true {
+			if err != nil {
+				t.Errorf("error occurred in testcase '%s', got:\n %v", c.testCase, err)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("expected errors in testcase '%s', got none", c.testCase)
+			}
+		}
+	}
+}
+
+type toCamelParams struct {
+	expectedString string
+	testString     string
+	testCase       string
+}
+
+func TestToCamel(t *testing.T) {
+	testParams := []toCamelParams{
+		{"testString", "TestString", "Best case"},
+		{"", "", "Empty string"},
+	}
+	for _, c := range testParams {
+		generatedStr := ToCamel(c.testString)
+		if generatedStr != c.expectedString {
+			t.Errorf("expected both strings to be %s, generated string was: %s", c.expectedString, generatedStr)
+		}
+	}
+}
+
+type toPascalParams struct {
+	expectedString string
+	testString     string
+	testCase       string
+}
+
+func TestToPascal(t *testing.T) {
+	testParams := []toPascalParams{
+		{"TestString", "testString", "Best case"},
+		{"", "", "Empty string"},
+	}
+	for _, c := range testParams {
+		generatedStr := ToPascal(c.testString)
+		if generatedStr != c.expectedString {
+			t.Errorf("expected both strings to be %s in testcase '%s', generated string was: %s", c.expectedString, c.testCase, generatedStr)
+		}
+	}
+}
+
+type isFirstUpperParams struct {
+	expectedUpper bool
+	testString    string
+	testCase      string
+}
+
+func TestIsFirstLetterUpper(t *testing.T) {
+	testParams := []isFirstUpperParams{
+		{true, "FirstUpper", "First letter is uppercase"},
+		{false, "firstUpper", "First letter is not uppercase"},
+		{false, "", "Empty string"},
+	}
+	for _, c := range testParams {
+		isUpper := IsFirstLetterUpper(c.testString)
+		if isUpper != c.expectedUpper {
+			if c.expectedUpper == true {
+				t.Errorf("expected first letter to be uppercase in testcase '%s'", c.testCase)
+			} else {
+				t.Errorf("expected first letter to be lowercase in testcase '%s'", c.testCase)
+			}
+		}
+	}
+}
+
+type isFirstLowerParams struct {
+	expectedLower bool
+	testString    string
+	testCase      string
+}
+
+func TestIsFirstLetterLower(t *testing.T) {
+	testParams := []isFirstLowerParams{
+		{true, "firstLower", "First letter is lowercase"},
+		{false, "FirstLower", "First letter is not lowercase"},
+		{false, "", "Empty string"},
+	}
+	for _, c := range testParams {
+		isLower := IsFirstLetterLower(c.testString)
+		if isLower != c.expectedLower {
+			if c.expectedLower == true {
+				t.Errorf("expected first letter to be lowercase in testcase '%s'", c.testCase)
+			} else {
+				t.Errorf("expected first letter to be uppercase in testcase '%s'", c.testCase)
+			}
+		}
+	}
+}
+
+type isPascalCaseParams struct {
+	expectedPascal bool
+	testString     string
+	testCase       string
+}
+
+func TestIsPascalCase(t *testing.T) {
+	testParams := []isPascalCaseParams{
+		{true, "IsPascal", "Is Pascal"},
+		{false, "isPascal", "Not Pascal"},
+	}
+	for _, c := range testParams {
+		isPascal := IsPascalCase(c.testString)
+		if isPascal != c.expectedPascal {
+			if c.expectedPascal == true {
+				t.Errorf("expected first letter to be uppercase in testcase '%s'", c.testCase)
+			} else {
+				t.Errorf("expected first letter to be lowercase in testcase '%s'", c.testCase)
+			}
+		}
+	}
+}
+
+type isCamelCaseParams struct {
+	expectedCamel bool
+	testString    string
+	testCase      string
+}
+
+func TestICamelCase(t *testing.T) {
+	testParams := []isCamelCaseParams{
+		{true, "isCamel", "Is Camel"},
+		{false, "IsCamel", "Not Camel"},
+	}
+	for _, c := range testParams {
+		isCamel := IsCamelCase(c.testString)
+		if isCamel != c.expectedCamel {
+			if c.expectedCamel == true {
+				t.Errorf("expected first letter to be lowercase in testcase '%s'", c.testCase)
+			} else {
+				t.Errorf("expected first letter to be uppercase in testcase '%s'", c.testCase)
+			}
+		}
+	}
+}

From b0062323443c7b9bdc8174705b4afca7466734d6 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 26 Jun 2025 17:55:13 +0200
Subject: [PATCH 085/186] Removed commented out code

---
 usecases/utilities.go | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/usecases/utilities.go b/usecases/utilities.go
index 2d97e52..921301c 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -60,10 +60,8 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 		if len(trimmed) > 0 {
 			switch trimmed[0] {
 			case '{', '[':
-				//log.Println("Detected JSON in text/plain payload.")
 				contentType = "application/json"
 			case '<':
-				//log.Println("Detected XML in text/plain payload.")
 				contentType = "application/xml"
 			default:
 				return nil, fmt.Errorf("plain text content is neither valid JSON nor XML")
@@ -77,12 +75,10 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, &rawData); err != nil {
-			//log.Printf("Error unmarshalling JSON: %v", err)
 			return nil, fmt.Errorf("error unmarshalling JSON: %v", err)
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, &rawData); err != nil {
-			//log.Printf("Error unmarshalling XML: %v", err)
 			return nil, fmt.Errorf("error unmarshalling XML: %v", err)
 		}
 	default:

From 0b1d699cc31b50c2d4a909bf3600bd94ecd3d75b Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Fri, 27 Jun 2025 15:07:49 +0200
Subject: [PATCH 086/186] Fixed changes requested during PR

---
 usecases/extra_utils_test.go |  21 ++++
 usecases/utilities.go        |   8 +-
 usecases/utilities_test.go   | 213 ++++++++++++++++-------------------
 3 files changed, 121 insertions(+), 121 deletions(-)

diff --git a/usecases/extra_utils_test.go b/usecases/extra_utils_test.go
index 4b48685..5d24cd9 100644
--- a/usecases/extra_utils_test.go
+++ b/usecases/extra_utils_test.go
@@ -2,10 +2,12 @@ package usecases
 
 import (
 	"context"
+	"encoding/xml"
 	"fmt"
 	"net/http"
 
 	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/forms"
 )
 
 // mockTransport is used for replacing the default network Transport (used by
@@ -67,6 +69,25 @@ func (mua mockUnitAsset) GetDetails() map[string][]string {
 
 func (mua mockUnitAsset) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {}
 
+// A mocked form used for testing
+type mockForm struct {
+	XMLName xml.Name `json:"-" xml:"testName"`
+	Value   any      `json:"value" xml:"value"`
+	Unit    string   `json:"unit" xml:"unit"`
+	Version string   `json:"version" xml:"version"`
+}
+
+// NewForm creates a new form
+func (f mockForm) NewForm() forms.Form {
+	f.Version = "testVersion"
+	return f
+}
+
+// FormVersion returns the version of the form
+func (f mockForm) FormVersion() string {
+	return f.Version
+}
+
 // Create a error reader to break json.Unmarshal()
 type errReader int
 
diff --git a/usecases/utilities.go b/usecases/utilities.go
index 921301c..535174a 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -75,11 +75,11 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, &rawData); err != nil {
-			return nil, fmt.Errorf("error unmarshalling JSON: %v", err)
+			return nil, fmt.Errorf("error unmarshalling JSON: %w", err)
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, &rawData); err != nil {
-			return nil, fmt.Errorf("error unmarshalling XML: %v", err)
+			return nil, fmt.Errorf("error unmarshalling XML: %w", err)
 		}
 	default:
 		return nil, fmt.Errorf("unsupported content type")
@@ -104,11 +104,11 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	switch {
 	case strings.Contains(contentType, "application/json"):
 		if err := json.Unmarshal(data, formInstance); err != nil {
-			return nil, fmt.Errorf("error unmarshalling JSON into form: %v", err)
+			return nil, fmt.Errorf("error unmarshalling JSON into form: %w", err)
 		}
 	case strings.Contains(contentType, "application/xml"):
 		if err := xml.Unmarshal(data, formInstance); err != nil {
-			return nil, fmt.Errorf("error unmarshalling XML into form: %v", err)
+			return nil, fmt.Errorf("error unmarshalling XML into form: %w", err)
 		}
 	}
 
diff --git a/usecases/utilities_test.go b/usecases/utilities_test.go
index 111bddf..321a856 100644
--- a/usecases/utilities_test.go
+++ b/usecases/utilities_test.go
@@ -11,27 +11,9 @@ import (
 	"github.com/sdoque/mbaigo/forms"
 )
 
-type mockForm struct {
-	XMLName xml.Name `json:"-" xml:"testName"`
-	Value   float64  `json:"value" xml:"value"`
-	Unit    string   `json:"unit" xml:"unit"`
-	Version string   `json:"version" xml:"version"`
-}
-
-// NewForm creates a new form
-func (f mockForm) NewForm() forms.Form {
-	f.Version = "testVersion"
-	return f
-}
-
-// FormVersion returns the version of the form
-func (f mockForm) FormVersion() string {
-	return f.Version
-}
-
 // Returns a form containing test values
-func createTestForm() (f mockForm) {
-	form := mockForm{
+func createTestForm() (form mockForm) {
+	form = mockForm{
 		XMLName: xml.Name{},
 		Value:   123,
 		Unit:    "testUnit",
@@ -40,117 +22,112 @@ func createTestForm() (f mockForm) {
 	return form
 }
 
-type brokenMockForm struct {
-	XMLName xml.Name  `json:"-" xml:"testName"`
-	Value   complex64 `json:"value" xml:"value"`
-	Unit    string    `json:"unit" xml:"unit"`
-	Version string    `json:"version" xml:"version"`
-}
-
-// NewForm creates a new form
-func (f brokenMockForm) NewForm() forms.Form {
-	f.Version = "testVersion"
-	return f
-}
-
-// FormVersion returns the version of the form
-func (f brokenMockForm) FormVersion() string {
-	return f.Version
+type assureParams struct {
+	contentType  string
+	checkName    func(string, []string) []string
+	checkValue   func(string, []string) []string
+	checkUnit    func(string, []string) []string
+	checkVersion func(string, []string) []string
 }
 
-// Returns a form containing complex numbers, which xml and json can't marshal
-func createBrokenTestForm() (f brokenMockForm) {
-	form := brokenMockForm{
-		XMLName: xml.Name{},
-		Value:   complex(1, 2),
-		Unit:    "testUnit",
-		Version: "testVersion",
+// Returns an error containing a list of values who was missing/wrong
+func assurePackData(byteArr []byte, contentType string) (err error) {
+	testParams := []assureParams{
+		// Parameters and function for checking xml data
+		{
+			"application/xml",
+			func(data string, missingList []string) []string {
+				if strings.Contains(data, "<testName>") == false {
+					missingList = append(missingList, "name")
+				}
+				return missingList
+			},
+			func(data string, missingList []string) []string {
+				if strings.Contains(data, "<value>123</value>") == false {
+					missingList = append(missingList, "value")
+				}
+				return missingList
+			},
+			func(data string, missingList []string) []string {
+				if strings.Contains(data, "<unit>testUnit</unit>") == false {
+					missingList = append(missingList, "unit")
+				}
+				return missingList
+			},
+			func(data string, missingList []string) []string {
+				if strings.Contains(data, "<version>testVersion</version>") == false {
+					missingList = append(missingList, "version")
+				}
+				return missingList
+			},
+		},
+		// Parameters and functions for checking json data
+		{
+			"application/json",
+			func(data string, missingList []string) []string { return missingList },
+			func(data string, missingList []string) []string {
+				if strings.Contains(data, `"value": 123`) == false {
+					missingList = append(missingList, "value")
+				}
+				return missingList
+			},
+			func(data string, missingList []string) []string {
+				if strings.Contains(data, `"unit": "testUnit"`) == false {
+					missingList = append(missingList, "unit")
+				}
+				return missingList
+			},
+			func(data string, missingList []string) []string {
+				if strings.Contains(data, `"version": "testVersion"`) == false {
+					missingList = append(missingList, "version")
+				}
+				return missingList
+			},
+		},
 	}
-	return form
+	// Loops through the param list, and checks if there's an element with the same contentType
+	for _, c := range testParams {
+		data := string(byteArr)
+		var missingList []string
+		if c.contentType == contentType {
+			// If there's an element with same contentType, run checks
+			missingList = c.checkName(data, missingList)
+			missingList = c.checkValue(data, missingList)
+			missingList = c.checkUnit(data, missingList)
+			missingList = c.checkVersion(data, missingList)
+		}
+		if len(missingList) != 0 {
+			return fmt.Errorf("fields containing wrong data: %v", missingList)
+		}
+	}
+	return err
 }
 
 type packParams struct {
 	contentType   string
-	form          forms.Form
 	expectedError bool
+	form          func() mockForm
+	assureData    func([]byte, string) error
 	testCase      string
 }
 
-// Returns an error containing a list values who was missing/wrong
-func assurePackData(byteArr []byte, contentType string, expectedError bool) (err error) {
-	data := string(byteArr)
-	if contentType == "application/xml" {
-		missingData := []string{}
-		correctName := strings.Contains(data, "<testName>")
-		if correctName != true {
-			missingData = append(missingData, "XMLName")
-		}
-		if expectedError == false {
-			correctValue := strings.Contains(data, "<value>123</value>")
-			if correctValue != true {
-				missingData = append(missingData, "Value")
-			}
-		} else {
-			correctValue := strings.Contains(data, "<value>(1+2i)</value>")
-			if correctValue != true {
-				missingData = append(missingData, "Value")
-			}
-		}
-		correctUnit := strings.Contains(data, "<unit>testUnit</unit>")
-		if correctUnit != true {
-			missingData = append(missingData, "Unit")
-		}
-		correctVersion := strings.Contains(data, "<version>testVersion</version>")
-		if correctVersion != true {
-			missingData = append(missingData, "Version")
-		}
-		if len(missingData) != 0 {
-			return fmt.Errorf("missing data: %s", missingData)
-		}
-	} else {
-		missingData := []string{}
-		if expectedError == false {
-			correctValue := strings.Contains(data, `"value": 123`)
-			if correctValue != true {
-				missingData = append(missingData, "Value")
-			}
-		} else {
-			correctValue := strings.Contains(data, `"value": (1+2i)`)
-			if correctValue != true {
-				missingData = append(missingData, "Value")
-			}
-		}
-		correctUnit := strings.Contains(data, `"unit": "testUnit"`)
-		if correctUnit != true {
-			missingData = append(missingData, "Unit")
-		}
-		correctVersion := strings.Contains(data, `"version": "testVersion"`)
-		if correctVersion != true {
-			missingData = append(missingData, "Version")
-		}
-		if len(missingData) != 0 {
-			return fmt.Errorf("missing data: %s", missingData)
-		}
-	}
-	return nil
-}
-
 func TestPack(t *testing.T) {
 	params := []packParams{
-		{"application/xml", createTestForm(), false, "Best case, xml"},
-		{"application/json", createTestForm(), false, "Best case, json"},
-		{"application/xml", createBrokenTestForm(), true, "Bad case, xml"},
-		{"application/json", createBrokenTestForm(), true, "Bad case, json"},
+		{"application/xml", false, func() mockForm { return createTestForm() }, func(byteArr []byte, cType string) error { return assurePackData(byteArr, cType) }, "Best case, xml"},
+		{"application/json", false, func() mockForm { return createTestForm() }, func(byteArr []byte, cType string) error { return assurePackData(byteArr, cType) }, "Best case, json"},
+		{"application/xml", true, func() mockForm { form := createTestForm(); form.Value = complex(1, 2); return form }, nil, "Bad case, xml"},
+		{"application/json", true, func() mockForm { form := createTestForm(); form.Value = complex(1, 2); return form }, nil, "Bad case, json"},
 	}
 	for _, c := range params {
-		data, err := Pack(c.form, c.contentType)
+		data, err := Pack(c.form(), c.contentType)
 		if c.expectedError == false {
 			if err != nil {
 				t.Errorf("failed in testcase '%s' with error: %v", c.testCase, err)
 			}
-			err = assurePackData(data, c.contentType, c.expectedError)
+			// Only assure data if we expect and get no errors from Pack() since data will be empty if we get an error
+			err = c.assureData(data, c.contentType)
 			if err != nil {
-				t.Errorf("error from assureData: %v", err)
+				t.Errorf("error from assureData in testcase '%s': %v", c.testCase, err)
 			}
 		} else {
 			if err == nil {
@@ -187,12 +164,14 @@ func TestUnpack(t *testing.T) {
 			data, err = json.Marshal(f)
 			return
 		}},
-		/* {false, "Best case, xml", "text/plain", func() (data []byte, err error) {
+		// TODO: The following test can't be done because xml.Unmarshal() can't unmarshal to map[]
+		// fails with "error unmarshalling XML: unknown type map[string]interface {}"
+		/*{false, "Best case, xml", "text/plain", func() (data []byte, err error) {
 			var f forms.SignalA_v1a
 			f.NewForm()
 			data, err = xml.Marshal(f)
 			return
-		}}, */
+		}},*/
 		{true, "Bad case, not json/xml", "text/plain", func() (data []byte, err error) { return []byte("TEST123"), nil }},
 		{true, "Bad case, empty []byte", "text/plain", func() (data []byte, err error) { return []byte(""), nil }},
 		{true, "Bad case, unsupported content type", "unknown", func() (data []byte, err error) { return []byte("test"), nil }},
@@ -215,12 +194,12 @@ func TestUnpack(t *testing.T) {
 			data = append(data, byte(math.NaN()))
 			return data, err
 		}},
-		// Can't reach second unmarshal for json to break it this way, moving on.
-		/* {true, "Bad case, broken unmarshal in xml", "application/xml", func() (data []byte, err error) {
+		// TODO: Refactor code so we can do this test: currently can't reach second unmarshal for json to break it this way, moving on.
+		{true, "Bad case, broken unmarshal in xml", "application/xml", func() (data []byte, err error) {
 			data = append(data, byte(math.NaN()))
 			return data, err
-		}}, */
-		// Can't reach second unmarshal for xml to break it this way, moving on.
+		}},
+		// TODO: Refactor code so we can do this test: currently can't reach second unmarshal for xml to break it this way, moving on.
 	}
 
 	for _, c := range testParams {

From 0d9448c5ada370dee2239b5e3cccd1cbe0d719d3 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Fri, 27 Jun 2025 18:15:51 +0200
Subject: [PATCH 087/186] After live PR, removed help functions and simplified
 data assurance checks

---
 usecases/utilities_test.go | 125 +++++--------------------------------
 1 file changed, 17 insertions(+), 108 deletions(-)

diff --git a/usecases/utilities_test.go b/usecases/utilities_test.go
index 321a856..92c0139 100644
--- a/usecases/utilities_test.go
+++ b/usecases/utilities_test.go
@@ -2,8 +2,6 @@ package usecases
 
 import (
 	"encoding/json"
-	"encoding/xml"
-	"fmt"
 	"math"
 	"strings"
 	"testing"
@@ -11,124 +9,35 @@ import (
 	"github.com/sdoque/mbaigo/forms"
 )
 
-// Returns a form containing test values
-func createTestForm() (form mockForm) {
-	form = mockForm{
-		XMLName: xml.Name{},
-		Value:   123,
-		Unit:    "testUnit",
-		Version: "testVersion",
-	}
-	return form
-}
-
-type assureParams struct {
-	contentType  string
-	checkName    func(string, []string) []string
-	checkValue   func(string, []string) []string
-	checkUnit    func(string, []string) []string
-	checkVersion func(string, []string) []string
-}
-
-// Returns an error containing a list of values who was missing/wrong
-func assurePackData(byteArr []byte, contentType string) (err error) {
-	testParams := []assureParams{
-		// Parameters and function for checking xml data
-		{
-			"application/xml",
-			func(data string, missingList []string) []string {
-				if strings.Contains(data, "<testName>") == false {
-					missingList = append(missingList, "name")
-				}
-				return missingList
-			},
-			func(data string, missingList []string) []string {
-				if strings.Contains(data, "<value>123</value>") == false {
-					missingList = append(missingList, "value")
-				}
-				return missingList
-			},
-			func(data string, missingList []string) []string {
-				if strings.Contains(data, "<unit>testUnit</unit>") == false {
-					missingList = append(missingList, "unit")
-				}
-				return missingList
-			},
-			func(data string, missingList []string) []string {
-				if strings.Contains(data, "<version>testVersion</version>") == false {
-					missingList = append(missingList, "version")
-				}
-				return missingList
-			},
-		},
-		// Parameters and functions for checking json data
-		{
-			"application/json",
-			func(data string, missingList []string) []string { return missingList },
-			func(data string, missingList []string) []string {
-				if strings.Contains(data, `"value": 123`) == false {
-					missingList = append(missingList, "value")
-				}
-				return missingList
-			},
-			func(data string, missingList []string) []string {
-				if strings.Contains(data, `"unit": "testUnit"`) == false {
-					missingList = append(missingList, "unit")
-				}
-				return missingList
-			},
-			func(data string, missingList []string) []string {
-				if strings.Contains(data, `"version": "testVersion"`) == false {
-					missingList = append(missingList, "version")
-				}
-				return missingList
-			},
-		},
-	}
-	// Loops through the param list, and checks if there's an element with the same contentType
-	for _, c := range testParams {
-		data := string(byteArr)
-		var missingList []string
-		if c.contentType == contentType {
-			// If there's an element with same contentType, run checks
-			missingList = c.checkName(data, missingList)
-			missingList = c.checkValue(data, missingList)
-			missingList = c.checkUnit(data, missingList)
-			missingList = c.checkVersion(data, missingList)
-		}
-		if len(missingList) != 0 {
-			return fmt.Errorf("fields containing wrong data: %v", missingList)
-		}
-	}
-	return err
-}
-
 type packParams struct {
-	contentType   string
-	expectedError bool
-	form          func() mockForm
-	assureData    func([]byte, string) error
-	testCase      string
+	contentType     string
+	expectedError   bool
+	form            mockForm
+	expectedValue   string
+	expectedVersion string
+	testCase        string
 }
 
 func TestPack(t *testing.T) {
 	params := []packParams{
-		{"application/xml", false, func() mockForm { return createTestForm() }, func(byteArr []byte, cType string) error { return assurePackData(byteArr, cType) }, "Best case, xml"},
-		{"application/json", false, func() mockForm { return createTestForm() }, func(byteArr []byte, cType string) error { return assurePackData(byteArr, cType) }, "Best case, json"},
-		{"application/xml", true, func() mockForm { form := createTestForm(); form.Value = complex(1, 2); return form }, nil, "Bad case, xml"},
-		{"application/json", true, func() mockForm { form := createTestForm(); form.Value = complex(1, 2); return form }, nil, "Bad case, json"},
+		{"application/xml", false, mockForm{Value: 123, Version: "testVersion"}, "<value>123</value>", "<version>testVersion</version>", "Best case, xml"},
+		{"application/json", false, mockForm{Value: 123, Version: "testVersion"}, `"value": 123`, `"version": "testVersion"`, "Best case, json"},
+		{"application/xml", true, mockForm{Value: complex(1, 2), Version: "testVersion"}, "", "", "Bad case, xml"},
+		{"application/json", true, mockForm{Value: complex(1, 2), Version: "testVersion"}, "", "", "Bad case, json"},
 	}
 	for _, c := range params {
-		data, err := Pack(c.form(), c.contentType)
+		data, err := Pack(c.form, c.contentType)
 		if c.expectedError == false {
 			if err != nil {
 				t.Errorf("failed in testcase '%s' with error: %v", c.testCase, err)
 			}
-			// Only assure data if we expect and get no errors from Pack() since data will be empty if we get an error
-			err = c.assureData(data, c.contentType)
-			if err != nil {
-				t.Errorf("error from assureData in testcase '%s': %v", c.testCase, err)
+			if strings.Contains(string(data), c.expectedValue) != true {
+				t.Errorf("value missing or wrong in testcase '%s'", c.testCase)
 			}
+			if strings.Contains(string(data), c.expectedVersion) != true {
+				t.Errorf("version missing or wrong in testcase '%s'", c.testCase)
+			}
+
 		} else {
 			if err == nil {
 				t.Errorf("expected error in testcase '%s', got none", c.testCase)

From 5ff2115671fee0c295b539572ea1c4b9658f6b59 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Fri, 27 Jun 2025 18:23:33 +0200
Subject: [PATCH 088/186] Moved/changed comments in TestUnpack() to not cause
 misunderstandings about what test is commented

---
 usecases/utilities_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/usecases/utilities_test.go b/usecases/utilities_test.go
index 92c0139..4ceb703 100644
--- a/usecases/utilities_test.go
+++ b/usecases/utilities_test.go
@@ -103,12 +103,12 @@ func TestUnpack(t *testing.T) {
 			data = append(data, byte(math.NaN()))
 			return data, err
 		}},
-		// TODO: Refactor code so we can do this test: currently can't reach second unmarshal for json to break it this way, moving on.
 		{true, "Bad case, broken unmarshal in xml", "application/xml", func() (data []byte, err error) {
 			data = append(data, byte(math.NaN()))
 			return data, err
 		}},
-		// TODO: Refactor code so we can do this test: currently can't reach second unmarshal for xml to break it this way, moving on.
+		// TODO: Refactor code so we can do another test: currently can't reach second unmarshal for json to break it this way, moving on.
+		// TODO: Refactor code so we can do another test: currently can't reach second unmarshal for xml to break it this way, moving on.
 	}
 
 	for _, c := range testParams {

From ef19ad1fb55cb02bd0cd7e326585528337823860 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 29 Jun 2025 14:09:50 +0200
Subject: [PATCH 089/186] Adds new linter to catch even more common mistakes

---
 Makefile | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index 0a06467..d347729 100644
--- a/Makefile
+++ b/Makefile
@@ -7,6 +7,7 @@ lint:
 	test -z $$(gofmt -l .) || (echo "Code isn't gofmt'ed!" && exit 1)
 	go vet $$(go list ./... | grep -v /tmp)
 	gosec -quiet -fmt=golint -exclude-dir="tmp" ./...
+	staticcheck ./...
 	# pointerinterface ./...
 
 # Runs spellchecker on the code and comments
@@ -29,9 +30,10 @@ analyse:
 # Updates 3rd party packages and tools
 installpkgs:
 	go mod download
-	go install github.com/securego/gosec/v2/cmd/gosec@latest
 	go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
-	go install code.larus.se/lmas/pointerinterface@latest
+	go install github.com/securego/gosec/v2/cmd/gosec@latest
+	go install honnef.co/go/tools/cmd/staticcheck@latest
+	# go install code.larus.se/lmas/pointerinterface@latest
 
 # Clean up built binary and other temporary files (ignores errors from rm)
 clean:

From 94793cd960750e1325e19451d9b71d87480ba545 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 29 Jun 2025 14:09:50 +0200
Subject: [PATCH 090/186] Fixes warnings from staticcheck

---
 components/system_test.go    | 15 +++++----------
 usecases/configuration.go    |  2 +-
 usecases/consumption_test.go |  2 +-
 3 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/components/system_test.go b/components/system_test.go
index dcf8f26..aa97bd2 100644
--- a/components/system_test.go
+++ b/components/system_test.go
@@ -58,11 +58,10 @@ func (ec errorReadCloser) Close() error {
 var errMockTrans = fmt.Errorf("mock error")
 
 type mockTrans struct {
-	status       int
-	body         string
-	err          error
-	errBody      error
-	errBodyClose error
+	status  int
+	body    string
+	err     error
+	errBody error
 }
 
 func newMockTransport() *mockTrans {
@@ -87,10 +86,6 @@ func (t *mockTrans) setBodyError() {
 	t.errBody = errMockTrans
 }
 
-func (t *mockTrans) setBodyCloseError() {
-	t.errBodyClose = errMockTrans
-}
-
 // RoundTrip method is required to fulfil the RoundTripper interface (as required by the DefaultClient).
 // It prevents the request from being sent over the network.
 func (t *mockTrans) RoundTrip(req *http.Request) (*http.Response, error) {
@@ -103,7 +98,7 @@ func (t *mockTrans) RoundTrip(req *http.Request) (*http.Response, error) {
 		Body: errorReadCloser{
 			strings.NewReader(t.body),
 			t.errBody,
-			t.errBodyClose,
+			nil,
 		},
 		ContentLength: int64(len(t.body)),
 		Request:       req,
diff --git a/usecases/configuration.go b/usecases/configuration.go
index e623df7..baf26ec 100644
--- a/usecases/configuration.go
+++ b/usecases/configuration.go
@@ -57,7 +57,7 @@ type configFileIn struct {
 	Resources []json.RawMessage       `json:"unit_assets"`
 }
 
-var ErrNewConfig = errors.New("A new configuration file has been created. Please update it and restart the system")
+var ErrNewConfig = errors.New("new config file was created")
 
 func setupDefaultConfig(sys *components.System) (defaultConfig templateOut, err error) {
 	var assetTemplate components.UnitAsset
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index 0af440c..c139fe3 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -57,7 +57,7 @@ var form forms.SignalA_v1a
 
 var errEmptyRespBody = errors.New("got empty response body")
 
-var errUnpack = errors.New("Problem unpacking response body")
+var errUnpack = errors.New("problem unpacking response body")
 
 func createTestBytes() []byte {
 	return []byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}")

From 80e6e9775cce92813e0b12c1d14b58b15530eb44 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Thu, 26 Jun 2025 17:29:38 +0200
Subject: [PATCH 091/186] Started making tests for usecases/provision.go

---
 usecases/provision_test.go | 52 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 usecases/provision_test.go

diff --git a/usecases/provision_test.go b/usecases/provision_test.go
new file mode 100644
index 0000000..0cc8c87
--- /dev/null
+++ b/usecases/provision_test.go
@@ -0,0 +1,52 @@
+package usecases
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/sdoque/mbaigo/forms"
+)
+
+type httpProcessGetRequestStruct struct {
+	inputW           http.ResponseWriter
+	inputR           *http.Request
+	inputF           forms.Form
+	body             func() *http.Response
+	mockTransportErr int
+	errHTTP          error
+	testName         string
+}
+
+func createHttpResponse() func() *http.Response {
+	httpResp := func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+		}
+	}
+	return httpResp
+}
+
+func createEmptyFormVersion() forms.Form {
+	form.NewForm()
+	form.Version = ""
+	return &form
+}
+
+var httpProcessGetRequestParams = []httpProcessGetRequestStruct{
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), createHttpResponse(), 0, nil, "Good case"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), nil, createHttpResponse(), 0, nil, "Bad case, form is nil"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createEmptyFormVersion(), createHttpResponse(), 0, nil, "Bad case, form version is empty"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), createHttpResponse(), 0, nil, "Good case"},
+}
+
+func TestHTTPProcessGetRequest(t *testing.T) {
+	for _, testCase := range httpProcessGetRequestParams {
+		HTTPProcessGetRequest(testCase.inputW, testCase.inputR, testCase.inputF)
+	}
+}

From 43e66f91e6c9fb21d5c6372ec18e8d3edf2af9b2 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Fri, 27 Jun 2025 17:16:06 +0200
Subject: [PATCH 092/186] Started working on tests for usecases/provision.go

---
 usecases/provision_test.go | 76 +++++++++++++++++++++++++++++++-------
 1 file changed, 62 insertions(+), 14 deletions(-)

diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index 0cc8c87..25bfd95 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -1,23 +1,42 @@
 package usecases
 
 import (
+	"encoding/xml"
+	"fmt"
 	"io"
 	"net/http"
-	"net/http/httptest"
 	"strings"
-	"testing"
 
 	"github.com/sdoque/mbaigo/forms"
 )
 
 type httpProcessGetRequestStruct struct {
-	inputW           http.ResponseWriter
-	inputR           *http.Request
-	inputF           forms.Form
-	body             func() *http.Response
-	mockTransportErr int
-	errHTTP          error
-	testName         string
+	inputW      http.ResponseWriter
+	inputR      *http.Request
+	inputF      forms.Form
+	expectedErr error
+	testName    string
+}
+
+type brokenTestValueForm struct {
+	XMLName xml.Name  `json:"-" xml:"testName"`
+	Value   complex64 `json:"value" xml:"value"`
+	Unit    string    `json:"unit" xml:"unit"`
+	Version string    `json:"version" xml:"version"`
+}
+
+type mockResponseWriter struct {
+	http.ResponseWriter
+}
+
+func (e *mockResponseWriter) Write(b []byte) (int, error) {
+	return 0, fmt.Errorf("Forced write error")
+}
+
+func (e *mockResponseWriter) WriteHeader(statusCode int) {}
+
+func (e *mockResponseWriter) Header() http.Header {
+	return make(http.Header)
 }
 
 func createHttpResponse() func() *http.Response {
@@ -38,15 +57,44 @@ func createEmptyFormVersion() forms.Form {
 	return &form
 }
 
+func (f brokenTestValueForm) NewForm() forms.Form {
+	f.Version = "testVersion"
+	return f
+}
+
+func (f brokenTestValueForm) FormVersion() string {
+	return f.Version
+}
+
+func createBrokenForm() brokenTestValueForm {
+	form := brokenTestValueForm{
+		XMLName: xml.Name{},
+		Value:   complex(1, 2),
+		Unit:    "testUnit",
+		Version: "testVersion",
+	}
+	return form
+}
+
+var mockError error = fmt.Errorf("A mock error")
+
+// TODO: Uncomment this test if we get approval to make it so that HTTPProcessGetRequest returns an error, also make sure the expectedErr gets it proper value then
+/*
 var httpProcessGetRequestParams = []httpProcessGetRequestStruct{
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), createHttpResponse(), 0, nil, "Good case"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), nil, createHttpResponse(), 0, nil, "Bad case, form is nil"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createEmptyFormVersion(), createHttpResponse(), 0, nil, "Bad case, form version is empty"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), createHttpResponse(), 0, nil, "Good case"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), nil, "Good case"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), nil, mockError, "Bad case, form is nil"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createEmptyFormVersion(), mockError, "Bad case, form version is empty"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createBrokenForm(), mockError, "Bad case, form value is invalid"},
+	{&mockResponseWriter{}, httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), mockError, "Bad case, Write fails"},
 }
 
 func TestHTTPProcessGetRequest(t *testing.T) {
 	for _, testCase := range httpProcessGetRequestParams {
-		HTTPProcessGetRequest(testCase.inputW, testCase.inputR, testCase.inputF)
+		err := HTTPProcessGetRequest(testCase.inputW, testCase.inputR, testCase.inputF)
+
+		if err != testCase.expectedErr {
+			t.Errorf("Expected %v, got: %v", testCase.expectedErr, err)
+		}
 	}
 }
+*/

From 1d2c2d14ee5931d4cf75ddaedf063d0c524d8a65 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 30 Jun 2025 14:34:39 +0200
Subject: [PATCH 093/186] Made tests for HTTPProcessSetRequest and
 getBestContentType

---
 usecases/provision_test.go | 101 +++++++++++++++++++++++++++++++++----
 1 file changed, 91 insertions(+), 10 deletions(-)

diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index 25bfd95..b78d8f7 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -5,7 +5,9 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/http/httptest"
 	"strings"
+	"testing"
 
 	"github.com/sdoque/mbaigo/forms"
 )
@@ -57,21 +59,12 @@ func createEmptyFormVersion() forms.Form {
 	return &form
 }
 
-func (f brokenTestValueForm) NewForm() forms.Form {
-	f.Version = "testVersion"
-	return f
-}
-
-func (f brokenTestValueForm) FormVersion() string {
-	return f.Version
-}
-
 func createBrokenForm() brokenTestValueForm {
 	form := brokenTestValueForm{
 		XMLName: xml.Name{},
 		Value:   complex(1, 2),
 		Unit:    "testUnit",
-		Version: "testVersion",
+		Version: "SignalA_v1.0",
 	}
 	return form
 }
@@ -98,3 +91,91 @@ func TestHTTPProcessGetRequest(t *testing.T) {
 	}
 }
 */
+
+type httpProcessSetRequestStruct struct {
+	inputW       http.ResponseWriter
+	inputR       *http.Request
+	expectedErr  error
+	expectedForm forms.SignalA_v1a
+	testName     string
+}
+
+func createForm() forms.SignalA_v1a {
+	form.NewForm()
+	return form
+}
+
+func createBody() io.ReadCloser {
+	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}")))
+}
+
+func createBrokenBody() io.ReadCloser {
+	return io.NopCloser(strings.NewReader(string([]byte{0})))
+}
+
+func createBodyWithNoformVersion() io.ReadCloser {
+	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"bersion\": \"SignalA_v1.0\"\n}")))
+}
+
+func createBodyWithWrongForm() io.ReadCloser {
+	return io.NopCloser(strings.NewReader(string("{\n  \"value\": \"not-a-number\",\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}")))
+}
+
+func createBodyWithWrongFormVersion() io.ReadCloser {
+	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}")))
+}
+
+func errorIsSame(err1 error, err2 error) bool {
+	switch {
+	case err1 == nil && err2 == nil:
+		return true
+	case err1 == nil || err2 == nil:
+		return false
+	default:
+		return true
+	}
+}
+
+var httpProcessSetRequestParams = []httpProcessSetRequestStruct{
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBody()), nil, createForm(), "Good case"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", io.NopCloser(errorReader{})), errBodyRead, forms.SignalA_v1a{}, "Bad case, ReadAll returns error"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBrokenBody()), errBodyRead, forms.SignalA_v1a{}, "Bad case, Unmarshal returns error"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithNoformVersion()), nil, forms.SignalA_v1a{}, "Bad case, version key missing"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongForm()), errBodyRead, forms.SignalA_v1a{}, "Bad case, Second Unmarshal breaks"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongFormVersion()), errBodyRead, forms.SignalA_v1a{}, "Bad case, version is wrong"},
+}
+
+func TestHTTPProcessSetRequest(t *testing.T) {
+	for _, testCase := range httpProcessSetRequestParams {
+		f, err := HTTPProcessSetRequest(testCase.inputW, testCase.inputR)
+
+		if f != testCase.expectedForm || !errorIsSame(err, testCase.expectedErr) {
+			t.Errorf("Expected %v and %v, got: %v and %v", testCase.expectedForm, testCase.expectedErr, f, err)
+		}
+	}
+}
+
+type getBestContentTypeStruct struct {
+	acceptHeaderInput     string
+	bestContentTypeOutput string
+	testName              string
+}
+
+var getBestContentTypeParams = []getBestContentTypeStruct{
+	{"", "application/json", "Good case, no accept header provided"},
+	{"application/xml", "application/xml", "Good case, accept header provided without q-values"},
+	{"application/xml;q=0.7, application/json;q=0.9", "application/json", "Good case, accept header provided with q-values"},
+	{"application/xml;q=wrong, application/json;q=1.1", "application/json", "Good case, xml gets skipped"},
+	{"application/xml;q=0.9, application/json;q=0.9", "application/xml", "Good case, equal q-values selects the first one"},
+	{"application/xml;q=-0.9", "application/json", "Good case, no MIME type found"},
+}
+
+func TestGetBestContentType(t *testing.T) {
+	for _, testCase := range getBestContentTypeParams {
+		res := getBestContentType(testCase.acceptHeaderInput)
+
+		if res != testCase.bestContentTypeOutput {
+			t.Errorf("Expected %v, got: %v in test case: %s", testCase.bestContentTypeOutput, res, testCase.testName)
+		}
+	}
+}

From 242f25fcf9f0a9c6c107bbb5ff6fc48adc13e5cc Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 30 Jun 2025 16:40:16 +0200
Subject: [PATCH 094/186] Made tests for HTTPProcessGetRequest

---
 usecases/provision_test.go | 86 +++++++++++++++++++++++++-------------
 1 file changed, 58 insertions(+), 28 deletions(-)

diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index b78d8f7..f34fa11 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -1,6 +1,7 @@
 package usecases
 
 import (
+	"bytes"
 	"encoding/xml"
 	"fmt"
 	"io"
@@ -13,11 +14,18 @@ import (
 )
 
 type httpProcessGetRequestStruct struct {
-	inputW      http.ResponseWriter
-	inputR      *http.Request
-	inputF      forms.Form
-	expectedErr error
-	testName    string
+	inputW       http.ResponseWriter
+	inputR       *http.Request
+	inputF       forms.Form
+	expectedBody string
+	testName     string
+}
+
+type wrongVersionForm struct {
+	XMLName xml.Name  `json:"-" xml:"testName"`
+	Value   complex64 `json:"value" xml:"value"`
+	Unit    string    `json:"unit" xml:"unit"`
+	Version string    `json:"version" xml:"version"`
 }
 
 type brokenTestValueForm struct {
@@ -41,22 +49,36 @@ func (e *mockResponseWriter) Header() http.Header {
 	return make(http.Header)
 }
 
-func createHttpResponse() func() *http.Response {
-	httpResp := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
-		}
+func createNewBodyString() string {
+	return "{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"
+}
+
+func (f wrongVersionForm) NewForm() forms.Form {
+	f.Version = ""
+	return f
+}
+
+func (f wrongVersionForm) FormVersion() string {
+	return f.Version
+}
+
+func createEmptyFormVersion() wrongVersionForm {
+	form := wrongVersionForm{
+		XMLName: xml.Name{},
+		Value:   0,
+		Unit:    "testUnit",
+		Version: "",
 	}
-	return httpResp
+	return form
 }
 
-func createEmptyFormVersion() forms.Form {
-	form.NewForm()
-	form.Version = ""
-	return &form
+func (f brokenTestValueForm) NewForm() forms.Form {
+	f.Version = "testVersion"
+	return f
+}
+
+func (f brokenTestValueForm) FormVersion() string {
+	return f.Version
 }
 
 func createBrokenForm() brokenTestValueForm {
@@ -72,25 +94,32 @@ func createBrokenForm() brokenTestValueForm {
 var mockError error = fmt.Errorf("A mock error")
 
 // TODO: Uncomment this test if we get approval to make it so that HTTPProcessGetRequest returns an error, also make sure the expectedErr gets it proper value then
-/*
+
 var httpProcessGetRequestParams = []httpProcessGetRequestStruct{
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), nil, "Good case"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), nil, mockError, "Bad case, form is nil"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createEmptyFormVersion(), mockError, "Bad case, form version is empty"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createBrokenForm(), mockError, "Bad case, form value is invalid"},
-	{&mockResponseWriter{}, httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), mockError, "Bad case, Write fails"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), createNewBodyString(), "Good case"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), nil, "No payload found.", "Bad case, form is nil"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createEmptyFormVersion(), "No payload information found.", "Bad case, form version is empty"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createBrokenForm(), "Error packing response:", "Bad case, form value is invalid"},
+	{&mockResponseWriter{}, httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), "", "Bad case, Write fails"},
 }
 
 func TestHTTPProcessGetRequest(t *testing.T) {
 	for _, testCase := range httpProcessGetRequestParams {
-		err := HTTPProcessGetRequest(testCase.inputW, testCase.inputR, testCase.inputF)
+		HTTPProcessGetRequest(testCase.inputW, testCase.inputR, testCase.inputF)
 
-		if err != testCase.expectedErr {
-			t.Errorf("Expected %v, got: %v", testCase.expectedErr, err)
+		if testCase.testName == "Bad case, Write fails" {
+			if _, ok := testCase.inputW.(*mockResponseWriter); !ok {
+				t.Errorf("Expected inputW to be of type *mockResponseWriter")
+			}
+		}
+		recorder, ok := testCase.inputW.(*httptest.ResponseRecorder)
+		if ok {
+			if !bytes.HasPrefix(recorder.Body.Bytes(), []byte(testCase.expectedBody)) {
+				t.Errorf("Expected %v, got: %v", testCase.expectedBody, recorder.Body.String())
+			}
 		}
 	}
 }
-*/
 
 type httpProcessSetRequestStruct struct {
 	inputW       http.ResponseWriter
@@ -102,6 +131,7 @@ type httpProcessSetRequestStruct struct {
 
 func createForm() forms.SignalA_v1a {
 	form.NewForm()
+	form.Value = 0
 	return form
 }
 

From 6747d5e4852749a8b78aed3f92791d7acaa2a968 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Tue, 1 Jul 2025 15:47:10 +0200
Subject: [PATCH 095/186] Completed tests for usecases/provision.go

---
 usecases/provision.go      | 32 +++++++--------------------
 usecases/provision_test.go | 45 ++++++++++++++++----------------------
 2 files changed, 27 insertions(+), 50 deletions(-)

diff --git a/usecases/provision.go b/usecases/provision.go
index 83bae9b..444f0de 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -20,8 +20,6 @@
 package usecases
 
 import (
-	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"log"
@@ -61,37 +59,23 @@ func HTTPProcessGetRequest(w http.ResponseWriter, r *http.Request, f forms.Form)
 }
 
 // HTTPProcessSetRequest processes a SET request
-func HTTPProcessSetRequest(w http.ResponseWriter, req *http.Request) (f forms.SignalA_v1a, err error) {
+func HTTPProcessSetRequest(w http.ResponseWriter, req *http.Request) (forms.SignalA_v1a, error) {
 	defer req.Body.Close()
 	bodyBytes, err := io.ReadAll(req.Body) // Use io.ReadAll instead of ioutil.ReadAll
 	if err != nil {
 		log.Printf("Error reading request body: %v", err)
-		return
+		return forms.SignalA_v1a{}, err
 	}
-	var jsonData map[string]interface{}
-	err = json.Unmarshal(bodyBytes, &jsonData)
+	headerContentType := req.Header.Get("Content-Type")
+	form, err := Unpack(bodyBytes, headerContentType)
 	if err != nil {
-		log.Printf("Error unmarshalling JSON data: %v", err)
-		return
+		return forms.SignalA_v1a{}, err
 	}
-	formVersion, ok := jsonData["version"].(string)
+	f, ok := form.(*forms.SignalA_v1a)
 	if !ok {
-		log.Printf("Error: 'version' key not found in JSON data")
-		return
-	}
-	switch formVersion {
-	case "SignalA_v1.0":
-		var sig forms.SignalA_v1a
-		err = json.Unmarshal(bodyBytes, &sig)
-		if err != nil {
-			log.Println("Unable to extract signal set request ")
-			return
-		}
-		f = sig
-	default:
-		err = errors.New("unsupported service set request form version")
+		return forms.SignalA_v1a{}, fmt.Errorf("Form is not of type SignalA_v1a")
 	}
-	return
+	return *f, nil
 }
 
 // getBestContentType parses the Accept header and returns the best content type based on q-values
diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index f34fa11..97547e5 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -1,7 +1,6 @@
 package usecases
 
 import (
-	"bytes"
 	"encoding/xml"
 	"fmt"
 	"io"
@@ -93,13 +92,11 @@ func createBrokenForm() brokenTestValueForm {
 
 var mockError error = fmt.Errorf("A mock error")
 
-// TODO: Uncomment this test if we get approval to make it so that HTTPProcessGetRequest returns an error, also make sure the expectedErr gets it proper value then
-
 var httpProcessGetRequestParams = []httpProcessGetRequestStruct{
 	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), createNewBodyString(), "Good case"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), nil, "No payload found.", "Bad case, form is nil"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createEmptyFormVersion(), "No payload information found.", "Bad case, form version is empty"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createBrokenForm(), "Error packing response:", "Bad case, form value is invalid"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), nil, "No payload found.\n", "Bad case, form is nil"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createEmptyFormVersion(), "No payload information found.\n", "Bad case, form version is empty"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createBrokenForm(), "Error packing response: error encoding JSON: json: unsupported type: complex64\n", "Bad case, form value is invalid"},
 	{&mockResponseWriter{}, httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), "", "Bad case, Write fails"},
 }
 
@@ -114,8 +111,8 @@ func TestHTTPProcessGetRequest(t *testing.T) {
 		}
 		recorder, ok := testCase.inputW.(*httptest.ResponseRecorder)
 		if ok {
-			if !bytes.HasPrefix(recorder.Body.Bytes(), []byte(testCase.expectedBody)) {
-				t.Errorf("Expected %v, got: %v", testCase.expectedBody, recorder.Body.String())
+			if recorder.Body.String() != testCase.expectedBody {
+				t.Errorf("Expected %s, got: %s", testCase.expectedBody, recorder.Body.String())
 			}
 		}
 	}
@@ -124,7 +121,7 @@ func TestHTTPProcessGetRequest(t *testing.T) {
 type httpProcessSetRequestStruct struct {
 	inputW       http.ResponseWriter
 	inputR       *http.Request
-	expectedErr  error
+	expectedErr  bool
 	expectedForm forms.SignalA_v1a
 	testName     string
 }
@@ -155,31 +152,27 @@ func createBodyWithWrongFormVersion() io.ReadCloser {
 	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}")))
 }
 
-func errorIsSame(err1 error, err2 error) bool {
-	switch {
-	case err1 == nil && err2 == nil:
-		return true
-	case err1 == nil || err2 == nil:
-		return false
-	default:
-		return true
-	}
-}
+var errReadAll error = fmt.Errorf("forced read error")
+
+var errUnmarshal error = fmt.Errorf("invalid character '\\x00' looking for beginning of value")
+
+var errVersion error = fmt.Errorf("unsupported service set request form version")
 
 var httpProcessSetRequestParams = []httpProcessSetRequestStruct{
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBody()), nil, createForm(), "Good case"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", io.NopCloser(errorReader{})), errBodyRead, forms.SignalA_v1a{}, "Bad case, ReadAll returns error"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBrokenBody()), errBodyRead, forms.SignalA_v1a{}, "Bad case, Unmarshal returns error"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithNoformVersion()), nil, forms.SignalA_v1a{}, "Bad case, version key missing"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongForm()), errBodyRead, forms.SignalA_v1a{}, "Bad case, Second Unmarshal breaks"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongFormVersion()), errBodyRead, forms.SignalA_v1a{}, "Bad case, version is wrong"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBody()), false, createForm(), "Good case"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", io.NopCloser(errorReader{})), true, forms.SignalA_v1a{}, "Bad case, ReadAll returns error"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBrokenBody()), true, forms.SignalA_v1a{}, "Bad case, Unmarshal returns error"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithNoformVersion()), true, forms.SignalA_v1a{}, "Bad case, version key missing"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongForm()), true, forms.SignalA_v1a{}, "Bad case, Second Unmarshal breaks"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongFormVersion()), true, forms.SignalA_v1a{}, "Bad case, version is wrong"},
 }
 
 func TestHTTPProcessSetRequest(t *testing.T) {
 	for _, testCase := range httpProcessSetRequestParams {
+		testCase.inputR.Header.Set("Content-Type", "application/json")
 		f, err := HTTPProcessSetRequest(testCase.inputW, testCase.inputR)
 
-		if f != testCase.expectedForm || !errorIsSame(err, testCase.expectedErr) {
+		if f != testCase.expectedForm || (err == nil && testCase.expectedErr == true) || (err != nil && testCase.expectedErr == false) {
 			t.Errorf("Expected %v and %v, got: %v and %v", testCase.expectedForm, testCase.expectedErr, f, err)
 		}
 	}

From 54e436326fb02ad76d0e6f1687ba236801f76b98 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Tue, 1 Jul 2025 16:36:46 +0200
Subject: [PATCH 096/186] Added one more test as it was discovered one branch
 was not tested

---
 usecases/provision_test.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index 97547e5..d40800b 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -152,6 +152,10 @@ func createBodyWithWrongFormVersion() io.ReadCloser {
 	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}")))
 }
 
+func createBodyWithSignalBForm() io.ReadCloser {
+	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}")))
+}
+
 var errReadAll error = fmt.Errorf("forced read error")
 
 var errUnmarshal error = fmt.Errorf("invalid character '\\x00' looking for beginning of value")
@@ -165,6 +169,7 @@ var httpProcessSetRequestParams = []httpProcessSetRequestStruct{
 	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithNoformVersion()), true, forms.SignalA_v1a{}, "Bad case, version key missing"},
 	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongForm()), true, forms.SignalA_v1a{}, "Bad case, Second Unmarshal breaks"},
 	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongFormVersion()), true, forms.SignalA_v1a{}, "Bad case, version is wrong"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithSignalBForm()), true, forms.SignalA_v1a{}, "Bad case, form version is SignalB_v1a"},
 }
 
 func TestHTTPProcessSetRequest(t *testing.T) {

From 73fdf542c3e411e6e53d2f07294742b849dfb096 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Thu, 3 Jul 2025 10:31:58 +0200
Subject: [PATCH 097/186] Cleaned up some unused code, fixed PR comment and
 fixed a small miss in test of HTTPProcessSetRequest

---
 usecases/provision_test.go | 52 +++++---------------------------------
 1 file changed, 6 insertions(+), 46 deletions(-)

diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index d40800b..6146385 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -20,20 +20,6 @@ type httpProcessGetRequestStruct struct {
 	testName     string
 }
 
-type wrongVersionForm struct {
-	XMLName xml.Name  `json:"-" xml:"testName"`
-	Value   complex64 `json:"value" xml:"value"`
-	Unit    string    `json:"unit" xml:"unit"`
-	Version string    `json:"version" xml:"version"`
-}
-
-type brokenTestValueForm struct {
-	XMLName xml.Name  `json:"-" xml:"testName"`
-	Value   complex64 `json:"value" xml:"value"`
-	Unit    string    `json:"unit" xml:"unit"`
-	Version string    `json:"version" xml:"version"`
-}
-
 type mockResponseWriter struct {
 	http.ResponseWriter
 }
@@ -52,17 +38,8 @@ func createNewBodyString() string {
 	return "{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"
 }
 
-func (f wrongVersionForm) NewForm() forms.Form {
-	f.Version = ""
-	return f
-}
-
-func (f wrongVersionForm) FormVersion() string {
-	return f.Version
-}
-
-func createEmptyFormVersion() wrongVersionForm {
-	form := wrongVersionForm{
+func createEmptyFormVersion() mockForm {
+	form := mockForm{
 		XMLName: xml.Name{},
 		Value:   0,
 		Unit:    "testUnit",
@@ -71,17 +48,8 @@ func createEmptyFormVersion() wrongVersionForm {
 	return form
 }
 
-func (f brokenTestValueForm) NewForm() forms.Form {
-	f.Version = "testVersion"
-	return f
-}
-
-func (f brokenTestValueForm) FormVersion() string {
-	return f.Version
-}
-
-func createBrokenForm() brokenTestValueForm {
-	form := brokenTestValueForm{
+func createBrokenForm() mockForm {
+	form := mockForm{
 		XMLName: xml.Name{},
 		Value:   complex(1, 2),
 		Unit:    "testUnit",
@@ -90,13 +58,11 @@ func createBrokenForm() brokenTestValueForm {
 	return form
 }
 
-var mockError error = fmt.Errorf("A mock error")
-
 var httpProcessGetRequestParams = []httpProcessGetRequestStruct{
 	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), createNewBodyString(), "Good case"},
 	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), nil, "No payload found.\n", "Bad case, form is nil"},
 	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createEmptyFormVersion(), "No payload information found.\n", "Bad case, form version is empty"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createBrokenForm(), "Error packing response: error encoding JSON: json: unsupported type: complex64\n", "Bad case, form value is invalid"},
+	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createBrokenForm(), "Error packing response: error encoding JSON: json: unsupported type: complex128\n", "Bad case, form value is invalid"},
 	{&mockResponseWriter{}, httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), "", "Bad case, Write fails"},
 }
 
@@ -153,15 +119,9 @@ func createBodyWithWrongFormVersion() io.ReadCloser {
 }
 
 func createBodyWithSignalBForm() io.ReadCloser {
-	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}")))
+	return io.NopCloser(strings.NewReader(string("{\n  \"value\": false,\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}")))
 }
 
-var errReadAll error = fmt.Errorf("forced read error")
-
-var errUnmarshal error = fmt.Errorf("invalid character '\\x00' looking for beginning of value")
-
-var errVersion error = fmt.Errorf("unsupported service set request form version")
-
 var httpProcessSetRequestParams = []httpProcessSetRequestStruct{
 	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBody()), false, createForm(), "Good case"},
 	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", io.NopCloser(errorReader{})), true, forms.SignalA_v1a{}, "Bad case, ReadAll returns error"},

From 72c4f4d8a69041e8c790c8775bbca877e16523e0 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Thu, 3 Jul 2025 16:27:37 +0200
Subject: [PATCH 098/186] Fixed some PR comments

---
 usecases/provision.go      | 18 ++++++++-
 usecases/provision_test.go | 83 +++++++++++++++++---------------------
 2 files changed, 54 insertions(+), 47 deletions(-)

diff --git a/usecases/provision.go b/usecases/provision.go
index 444f0de..f8becd7 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -43,9 +43,23 @@ func HTTPProcessGetRequest(w http.ResponseWriter, r *http.Request, f forms.Form)
 	acceptHeader := r.Header.Get("Accept")
 	bestContentType := getBestContentType(acceptHeader)
 
+	/*
+		bodyBytes, err := io.ReadAll(r.Body)
+		if err != nil {
+			log.Printf("Error reading request body. %v", err)
+		}
+		defer r.Body.Close()
+		r.Body = io.NopCloser(bytes.NewReader(bodyBytes))
+		bestContentType := http.DetectContentType(bodyBytes)
+		if bestContentType == "application/octet-stream" {
+			bestContentType = "application/json"
+		}
+	*/
+
 	responseData, err := Pack(f, bestContentType)
 	if err != nil {
-		http.Error(w, fmt.Sprintf("Error packing response: %v", err), http.StatusInternalServerError)
+		log.Printf("Error packing response: %v", err)
+		http.Error(w, "Error packing response.", http.StatusInternalServerError)
 		return
 	}
 
@@ -53,8 +67,8 @@ func HTTPProcessGetRequest(w http.ResponseWriter, r *http.Request, f forms.Form)
 	w.WriteHeader(http.StatusOK)
 	_, err = w.Write(responseData)
 	if err != nil {
-		// TODO: More might need to happen here?
 		log.Printf("Error while writing response: %v", err)
+		http.Error(w, "Error writing response.", http.StatusInternalServerError)
 	}
 }
 
diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index 6146385..ec2e911 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -14,7 +14,7 @@ import (
 
 type httpProcessGetRequestStruct struct {
 	inputW       http.ResponseWriter
-	inputR       *http.Request
+	inputBody    string
 	inputF       forms.Form
 	expectedBody string
 	testName     string
@@ -34,10 +34,6 @@ func (e *mockResponseWriter) Header() http.Header {
 	return make(http.Header)
 }
 
-func createNewBodyString() string {
-	return "{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"
-}
-
 func createEmptyFormVersion() mockForm {
 	form := mockForm{
 		XMLName: xml.Name{},
@@ -59,16 +55,22 @@ func createBrokenForm() mockForm {
 }
 
 var httpProcessGetRequestParams = []httpProcessGetRequestStruct{
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), createNewBodyString(), "Good case"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), nil, "No payload found.\n", "Bad case, form is nil"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createEmptyFormVersion(), "No payload information found.\n", "Bad case, form version is empty"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/test123", nil), createBrokenForm(), "Error packing response: error encoding JSON: json: unsupported type: complex128\n", "Bad case, form value is invalid"},
-	{&mockResponseWriter{}, httptest.NewRequest(http.MethodGet, "/test123", nil), form.NewForm(), "", "Bad case, Write fails"},
+	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n}", form.NewForm(),
+		"{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}", "Good case"},
+	{httptest.NewRecorder(), "<form><value>0</value><unit></unit></form>", nil,
+		"No payload found.\n", "Bad case, form is nil"},
+	{httptest.NewRecorder(), "\n", createEmptyFormVersion(),
+		"No payload information found.\n", "Bad case, form version is empty"},
+	{httptest.NewRecorder(), "", createBrokenForm(),
+		"Error packing response.\n", "Bad case, form value is invalid"},
+	{&mockResponseWriter{}, "", form.NewForm(),
+		"", "Bad case, Write fails"},
 }
 
 func TestHTTPProcessGetRequest(t *testing.T) {
 	for _, testCase := range httpProcessGetRequestParams {
-		HTTPProcessGetRequest(testCase.inputW, testCase.inputR, testCase.inputF)
+		inputR := httptest.NewRequest(http.MethodGet, "/test123", io.NopCloser(strings.NewReader(testCase.inputBody)))
+		HTTPProcessGetRequest(testCase.inputW, inputR, testCase.inputF)
 
 		if testCase.testName == "Bad case, Write fails" {
 			if _, ok := testCase.inputW.(*mockResponseWriter); !ok {
@@ -86,7 +88,7 @@ func TestHTTPProcessGetRequest(t *testing.T) {
 
 type httpProcessSetRequestStruct struct {
 	inputW       http.ResponseWriter
-	inputR       *http.Request
+	inputBody    string
 	expectedErr  bool
 	expectedForm forms.SignalA_v1a
 	testName     string
@@ -98,49 +100,40 @@ func createForm() forms.SignalA_v1a {
 	return form
 }
 
-func createBody() io.ReadCloser {
-	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}")))
-}
-
-func createBrokenBody() io.ReadCloser {
-	return io.NopCloser(strings.NewReader(string([]byte{0})))
-}
-
-func createBodyWithNoformVersion() io.ReadCloser {
-	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"bersion\": \"SignalA_v1.0\"\n}")))
-}
-
-func createBodyWithWrongForm() io.ReadCloser {
-	return io.NopCloser(strings.NewReader(string("{\n  \"value\": \"not-a-number\",\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}")))
-}
-
-func createBodyWithWrongFormVersion() io.ReadCloser {
-	return io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}")))
-}
-
-func createBodyWithSignalBForm() io.ReadCloser {
-	return io.NopCloser(strings.NewReader(string("{\n  \"value\": false,\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}")))
-}
-
 var httpProcessSetRequestParams = []httpProcessSetRequestStruct{
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBody()), false, createForm(), "Good case"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", io.NopCloser(errorReader{})), true, forms.SignalA_v1a{}, "Bad case, ReadAll returns error"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBrokenBody()), true, forms.SignalA_v1a{}, "Bad case, Unmarshal returns error"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithNoformVersion()), true, forms.SignalA_v1a{}, "Bad case, version key missing"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongForm()), true, forms.SignalA_v1a{}, "Bad case, Second Unmarshal breaks"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithWrongFormVersion()), true, forms.SignalA_v1a{}, "Bad case, version is wrong"},
-	{httptest.NewRecorder(), httptest.NewRequest(http.MethodPut, "/test123", createBodyWithSignalBForm()), true, forms.SignalA_v1a{}, "Bad case, form version is SignalB_v1a"},
+	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}",
+		false, createForm(), "Good case"},
+	{httptest.NewRecorder(), "\n", true, forms.SignalA_v1a{}, "Bad case, Unmarshal returns error"},
+	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"bersion\": \"SignalA_v1.0\"\n}",
+		true, forms.SignalA_v1a{}, "Bad case, version key missing"},
+	{httptest.NewRecorder(), "{\n  \"value\": \"not-a-number\",\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}",
+		true, forms.SignalA_v1a{}, "Bad case, Second Unmarshal breaks"},
+	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}",
+		true, forms.SignalA_v1a{}, "Bad case, version is wrong"},
+	{httptest.NewRecorder(), "{\n  \"value\": false,\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}",
+		true, forms.SignalA_v1a{}, "Bad case, form version is SignalB_v1a"},
 }
 
 func TestHTTPProcessSetRequest(t *testing.T) {
 	for _, testCase := range httpProcessSetRequestParams {
-		testCase.inputR.Header.Set("Content-Type", "application/json")
-		f, err := HTTPProcessSetRequest(testCase.inputW, testCase.inputR)
+		inputR := httptest.NewRequest(http.MethodPut, "/test123", io.NopCloser(strings.NewReader(testCase.inputBody)))
+		inputR.Header.Set("Content-Type", "application/json")
+		f, err := HTTPProcessSetRequest(testCase.inputW, inputR)
 
 		if f != testCase.expectedForm || (err == nil && testCase.expectedErr == true) || (err != nil && testCase.expectedErr == false) {
 			t.Errorf("Expected %v and %v, got: %v and %v", testCase.expectedForm, testCase.expectedErr, f, err)
 		}
 	}
+
+	// Special case
+	specialRequest := httptest.NewRequest(http.MethodPut, "/test123", io.NopCloser(errorReader{}))
+	specialRequest.Header.Set("Content-Type", "application/json")
+	expectedForm := forms.SignalA_v1a{}
+	f, err := HTTPProcessSetRequest(httptest.NewRecorder(), specialRequest)
+
+	if f != expectedForm || err == nil {
+		t.Errorf("Expected %v, got: %v", expectedForm, f)
+	}
 }
 
 type getBestContentTypeStruct struct {

From c111e42ffb52675f0e32765a29a5b603e3e51ad2 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Thu, 3 Jul 2025 16:49:18 +0200
Subject: [PATCH 099/186] Fixed PR comment about leftover code

---
 usecases/provision.go | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/usecases/provision.go b/usecases/provision.go
index f8becd7..6b5b8fe 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -43,19 +43,6 @@ func HTTPProcessGetRequest(w http.ResponseWriter, r *http.Request, f forms.Form)
 	acceptHeader := r.Header.Get("Accept")
 	bestContentType := getBestContentType(acceptHeader)
 
-	/*
-		bodyBytes, err := io.ReadAll(r.Body)
-		if err != nil {
-			log.Printf("Error reading request body. %v", err)
-		}
-		defer r.Body.Close()
-		r.Body = io.NopCloser(bytes.NewReader(bodyBytes))
-		bestContentType := http.DetectContentType(bodyBytes)
-		if bestContentType == "application/octet-stream" {
-			bestContentType = "application/json"
-		}
-	*/
-
 	responseData, err := Pack(f, bestContentType)
 	if err != nil {
 		log.Printf("Error packing response: %v", err)

From 3089f4e968db1ca0e575cd7830fc4a9d36f0e96e Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 3 Jul 2025 18:48:12 +0200
Subject: [PATCH 100/186] Quick fix for a linter error about capitalised err
 strings

---
 usecases/provision.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/provision.go b/usecases/provision.go
index 6b5b8fe..7188dd0 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -74,7 +74,7 @@ func HTTPProcessSetRequest(w http.ResponseWriter, req *http.Request) (forms.Sign
 	}
 	f, ok := form.(*forms.SignalA_v1a)
 	if !ok {
-		return forms.SignalA_v1a{}, fmt.Errorf("Form is not of type SignalA_v1a")
+		return forms.SignalA_v1a{}, fmt.Errorf("form is not of type SignalA_v1a")
 	}
 	return *f, nil
 }

From 2229ba9599ca1e0e026973d759d541f01411a765 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 4 Jul 2025 10:06:07 +0200
Subject: [PATCH 101/186] Show cyclomatic complexity for the tests too

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index d347729..e8bb7f0 100644
--- a/Makefile
+++ b/Makefile
@@ -25,7 +25,7 @@ analyse:
 	@echo -e "\nCOVERAGE\n===================="
 	go tool cover -func=.cover.out
 	@echo -e "\nCYCLOMATIC COMPLEXITY\n===================="
-	gocyclo -avg -top 10 -ignore test.go .
+	gocyclo -avg -top 10 .
 
 # Updates 3rd party packages and tools
 installpkgs:

From 311c7783a82ba00b5823fd4eee0efb9d6235ee80 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 25 Jun 2025 17:06:44 +0200
Subject: [PATCH 102/186] Adds initial system and unit asset for integration
 test

---
 tests/integration_test.go | 160 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 160 insertions(+)
 create mode 100644 tests/integration_test.go

diff --git a/tests/integration_test.go b/tests/integration_test.go
new file mode 100644
index 0000000..32e8862
--- /dev/null
+++ b/tests/integration_test.go
@@ -0,0 +1,160 @@
+package tests
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/usecases"
+)
+
+// Force type check (fulfilling the interface) at compile time
+var _ components.UnitAsset = &uaGreeter{}
+
+// The most simplistic UnitAsset possible
+type uaGreeter struct {
+	Name        string              `json:"-"`
+	Owner       *components.System  `json:"-"`
+	Details     map[string][]string `json:"-"`
+	ServicesMap components.Services `json:"-"`
+	CervicesMap components.Cervices `json:"-"`
+	greeting    string
+}
+
+// Add required functions to fulfil the UnitAsset interface
+func (ua uaGreeter) GetName() string                  { return ua.Name }
+func (ua uaGreeter) GetServices() components.Services { return ua.ServicesMap }
+func (ua uaGreeter) GetCervices() components.Cervices { return ua.CervicesMap }
+func (ua uaGreeter) GetDetails() map[string][]string  { return ua.Details }
+func (ua uaGreeter) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
+	if servicePath != "greet" {
+		http.Error(w, "unknown service path: "+servicePath, http.StatusBadRequest)
+		return
+	}
+	if _, err := fmt.Fprintln(w, ua.greeting); err != nil {
+		http.Error(w, "error while writing greeting: "+err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func addGreeterTemplate(sys *components.System) {
+	greetService := &components.Service{
+		Definition: "greet", // The "name" of the service
+		SubPath:    "greet", // Not "allowed" to be changed afterwards
+		Details:    map[string][]string{"key": []string{"value"}},
+		RegPeriod:  60,
+		// NOTE: must start with lower-case, it gets embedded into another sentence in the web API
+		Description: "greets you with a message",
+	}
+	var ua components.UnitAsset
+	ua = &uaGreeter{
+		Name:    "greeter", // WARN: don't use the system name!! this is an asset!
+		Details: map[string][]string{"key": {"value"}},
+		ServicesMap: components.Services{
+			greetService.SubPath: greetService,
+		},
+	}
+	sys.UAssets[ua.GetName()] = &ua
+}
+
+func loadGreeter(ca usecases.ConfigurableAsset, sys *components.System) (components.UnitAsset, func()) {
+	ua := &uaGreeter{
+		Name:        ca.Name,
+		Owner:       sys,
+		Details:     ca.Details,
+		ServicesMap: usecases.MakeServiceMap(ca.Services),
+	}
+	return ua, func() {}
+}
+
+// Creates the most simplest system possible
+func newSystem() (*components.System, func(), error) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// TODO: want this to return a pointer type instead! easier to use and pointer is used all the time anyway down below
+	sys := components.NewSystem("test", ctx)
+	sys.Husk = &components.Husk{
+		Description: " is the most simplest system possible, used for performing integration tests",
+		Details:     map[string][]string{"key": {"value"}},
+		ProtoPort:   map[string]int{"http": 29999},
+	}
+
+	addGreeterTemplate(&sys)
+	rawResources, err := usecases.Configure(&sys)
+	if err != nil {
+		// TODO: check for ErrCreatedConfig blah, if so continue
+		cancel()
+		return nil, nil, err
+	}
+	// Don't leave any leftovers, no matter what
+	defer os.Remove("systemconfig.json")
+
+	// TODO: this could had been done already in Configure()?
+	// But that would need a change in the function signature
+	cleanups, err := LoadResources(&sys, rawResources, loadGreeter)
+	if err != nil {
+		cancel()
+		return nil, nil, err
+	}
+
+	// TODO: this is not ready for production yet?
+	// usecases.RequestCertificate(&sys)
+
+	// TODO: prints logs?
+	usecases.RegisterServices(&sys)
+
+	// TODO: prints logs??
+	go usecases.SetoutServers(&sys)
+
+	stop := func() {
+		cancel()
+		// TODO: this should be replaced with a wait group instead
+		time.Sleep(2 * time.Second)
+		cleanups()
+	}
+	return &sys, stop, nil
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// TODO: move to usecases/configure
+// TODO: this function really needs an error return too
+type NewResourceFunc func(usecases.ConfigurableAsset, *components.System) (components.UnitAsset, func())
+
+// TODO: move to usecases/configure
+func LoadResources(sys *components.System, rawRes []json.RawMessage, newRes NewResourceFunc) (func(), error) {
+	// Resets this map so it can be filled with loaded unit assets (rather than templates)
+	sys.UAssets = make(map[string]*components.UnitAsset)
+
+	var cleanups []func()
+	for _, raw := range rawRes {
+		var ca usecases.ConfigurableAsset
+		if err := json.Unmarshal(raw, &ca); err != nil {
+			return func() {}, err
+		}
+
+		ua, f := newRes(ca, sys)
+		sys.UAssets[ua.GetName()] = &ua
+		cleanups = append(cleanups, f)
+	}
+
+	doCleanups := func() {
+		for _, f := range cleanups {
+			f()
+		}
+	}
+	return doCleanups, nil
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+func TestSimpleSystemIntegration(t *testing.T) {
+	sys, stop, err := newSystem()
+	if err != nil {
+		panic(err) // TODO
+	}
+}

From 6a8adc4fc65bc19de16f5ce8d39f6aecb19e2610 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 26 Jun 2025 09:25:22 +0200
Subject: [PATCH 103/186] Fixes data race and cleans up error handling

---
 usecases/servers_handlers.go | 41 ++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 21 deletions(-)

diff --git a/usecases/servers_handlers.go b/usecases/servers_handlers.go
index 6341d18..1d09783 100644
--- a/usecases/servers_handlers.go
+++ b/usecases/servers_handlers.go
@@ -38,14 +38,13 @@ import (
 )
 
 // SetoutServers setups the http and https servers and starts them
-func SetoutServers(sys *components.System) (err error) {
+func SetoutServers(sys *components.System) error {
 	// get the servers port number (from configuration file)
 	httpPort := sys.Husk.ProtoPort["http"]
 	httpsPort := sys.Husk.ProtoPort["https"]
 
 	if httpPort == 0 && httpsPort == 0 {
-		fmt.Printf("The system %s has no web server configured\n", sys.Name)
-		return
+		return fmt.Errorf("missing http(s) port in configuration")
 	}
 
 	// how to handle requests to the servers
@@ -56,13 +55,13 @@ func SetoutServers(sys *components.System) (err error) {
 		// Encode the ECDSA private key to PEM format
 		privateKeyPEM, err := encodeECDSAPrivateKeyToPEM(sys.Husk.Pkey)
 		if err != nil {
-			log.Fatalf("Failed to encode private key: %v", err)
+			return fmt.Errorf("encoding private key: %w", err)
 		}
 
 		// Load the certificate and key
 		cert, err := tls.X509KeyPair([]byte(sys.Husk.Certificate), privateKeyPEM)
 		if err != nil {
-			log.Fatalf("Failed to parse certificate or private key: %v", err)
+			return fmt.Errorf("parsing certificate/private key: %w", err)
 		}
 
 		caCertPool := x509.NewCertPool()
@@ -89,22 +88,21 @@ func SetoutServers(sys *components.System) (err error) {
 		go func() {
 			<-sys.Ctx.Done()
 			time.Sleep(1 * time.Second) // this line is for the leading service registrar to deregister its own services
-			fmt.Printf("Initiating graceful shutdown of the HTTPS server.\n")
-			err = httpsServer.Shutdown(sys.Ctx)
-			if err != nil {
-				log.Printf("Error occurred during shutdown: %v", err)
+			// log.Printf("Initiating graceful shutdown of the HTTPS server.\n")
+			if err := httpsServer.Shutdown(sys.Ctx); err != nil {
+				log.Printf("Error during shutdown: %v", err)
 			}
 		}()
 
 		// Inform the user how to access the system's web server (black box documentation)
 		httpsURL := "https://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(httpsPort) + "/" + sys.Name
-		fmt.Printf("The system %s is up with its web server available at %s\n", sys.Name, httpsURL)
+		log.Printf("The system %s is up with its web server available at %s\n", sys.Name, httpsURL)
 
 		// Start and monitor the server
 		go func() {
-			err = httpsServer.ListenAndServeTLS("", "")
+			err := httpsServer.ListenAndServeTLS("", "")
 			if err != nil && err != http.ErrServerClosed {
-				log.Fatalf("Listen: %s\n", err)
+				log.Fatalf("Error from web server: %v\n", err)
 			}
 		}()
 	}
@@ -123,22 +121,23 @@ func SetoutServers(sys *components.System) (err error) {
 		go func() {
 			<-sys.Ctx.Done()
 			time.Sleep(1 * time.Second) // this line is for the leading service registrar to deregister its own services
-			fmt.Printf("Initiating graceful shutdown of the HTTP server.\n")
-			err = httpServer.Shutdown(sys.Ctx)
-			if err != nil {
-				log.Printf("Error occurred during shutdown: %v", err)
+			// log.Printf("Initiating graceful shutdown of the HTTP server.\n")
+			if err := httpServer.Shutdown(sys.Ctx); err != nil {
+				log.Printf("Error during shutdown: %v", err)
 			}
 		}()
 
 		// Inform the user how to access the system's web server (black box documentation)
 		httpURL := "http://" + sys.Host.IPAddresses[0] + ":" + strconv.Itoa(httpPort) + "/" + sys.Name
-		fmt.Printf("The system %s is up with its web server available at %s\n", sys.Name, httpURL)
+		log.Printf("The system %s is up with its web server available at %s\n", sys.Name, httpURL)
 
 		// Start and monitor the server
-		err = httpServer.ListenAndServe()
-		if err != nil && err != http.ErrServerClosed {
-			log.Fatalf("Listen: %s\n", err)
-		}
+		go func() {
+			err := httpServer.ListenAndServe()
+			if err != nil && err != http.ErrServerClosed {
+				log.Fatalf("Error from web server: %v\n", err)
+			}
+		}()
 	}
 
 	return nil

From 4ad1bc065be584adb80f6a173055516b3097027c Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 26 Jun 2025 09:25:22 +0200
Subject: [PATCH 104/186] Fixes second data race

---
 usecases/registration.go | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index 0cdeb9e..9dfd51a 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -28,6 +28,7 @@ import (
 	"net"
 	"net/http"
 	"strconv"
+	"sync"
 	"time"
 
 	"github.com/sdoque/mbaigo/components"
@@ -37,14 +38,19 @@ import (
 // RegisterServices keeps track of the leading Service Registrar and keeps all services registered
 func RegisterServices(sys *components.System) {
 	var leadRegistrarURL string
+	var mutex sync.RWMutex
 
 	// Goroutine looking for leading service registrar every 5 seconds
 	go func() {
 		ticker := time.NewTicker(5 * time.Second)
 		defer ticker.Stop()
 		for {
-			var err error
-			leadRegistrarURL, err = components.GetRunningCoreSystemURL(sys, components.ServiceRegistrarName)
+			newURL, err := components.GetRunningCoreSystemURL(sys, components.ServiceRegistrarName)
+			// The URL is shared between goroutines and thus must be protected
+			// from data races using a mutex. This could had been handled better.
+			mutex.Lock()
+			leadRegistrarURL = newURL
+			mutex.Unlock()
 			if err != nil {
 				log.Println("find lead registrar:", err)
 			}
@@ -66,11 +72,14 @@ func RegisterServices(sys *components.System) {
 				delay := 1 * time.Second
 				for {
 					timer := time.NewTimer(delay)
+					mutex.RLock()
+					regURL := leadRegistrarURL
+					mutex.RUnlock()
 					select {
 					case <-timer.C:
-						delay = registerService(sys, leadRegistrarURL, theUnitAsset, theService)
+						delay = registerService(sys, regURL, theUnitAsset, theService)
 					case <-sys.Ctx.Done():
-						err := unregisterService(leadRegistrarURL, theService)
+						err := unregisterService(regURL, theService)
 						if err != nil {
 							log.Println("unregistering service:", err)
 						}

From 5eb1da2698d31f4fc0f9efc878f1ee10ccd1bfdd Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 26 Jun 2025 09:25:22 +0200
Subject: [PATCH 105/186] Enabling by default the data race detection for tests

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index e8bb7f0..87d4a27 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,6 @@
 # Run tests and log the test coverage
 test:
-	go test -v -coverprofile=".cover.out" $$(go list ./... | grep -v /tmp)
+	go test -v -race -coverprofile=".cover.out" $$(go list ./... | grep -v /tmp)
 
 # Runs source code linters and catches common errors
 lint:

From 9db010722049b61b33247660841ecaf6de6affa3 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 26 Jun 2025 09:25:22 +0200
Subject: [PATCH 106/186] Improves use of delays and sharing registrar URL

Got some wonky behaviour, where registration was sent
to an empty URL and had to wait an extra 15 seconds
before being completed.
---
 usecases/registration.go | 43 ++++++++++++++++++++++++----------------
 1 file changed, 26 insertions(+), 17 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index 9dfd51a..cb7bf23 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -35,28 +35,41 @@ import (
 	"github.com/sdoque/mbaigo/forms"
 )
 
+type registrarTracker struct {
+	url   string
+	mutex sync.RWMutex
+}
+
+func (rt *registrarTracker) set(url string) {
+	rt.mutex.Lock()
+	rt.url = url
+	rt.mutex.Unlock()
+}
+
+func (rt *registrarTracker) get() string {
+	rt.mutex.RLock()
+	defer rt.mutex.RUnlock()
+	return rt.url
+}
+
 // RegisterServices keeps track of the leading Service Registrar and keeps all services registered
 func RegisterServices(sys *components.System) {
-	var leadRegistrarURL string
-	var mutex sync.RWMutex
+	// Keep track of the registrar URL. The URL is shared between goroutines,
+	// so it must be protected from data races using a mutex.
+	registrar := &registrarTracker{}
 
 	// Goroutine looking for leading service registrar every 5 seconds
 	go func() {
-		ticker := time.NewTicker(5 * time.Second)
-		defer ticker.Stop()
+		ticker := time.Tick(5 * time.Second)
 		for {
 			newURL, err := components.GetRunningCoreSystemURL(sys, components.ServiceRegistrarName)
-			// The URL is shared between goroutines and thus must be protected
-			// from data races using a mutex. This could had been handled better.
-			mutex.Lock()
-			leadRegistrarURL = newURL
-			mutex.Unlock()
+			registrar.set(newURL) // should be empty on error anyway
 			if err != nil {
 				log.Println("find lead registrar:", err)
 			}
 
 			select {
-			case <-ticker.C:
+			case <-ticker:
 			case <-sys.Ctx.Done():
 				return
 			}
@@ -71,15 +84,11 @@ func RegisterServices(sys *components.System) {
 			go func(theUnitAsset *components.UnitAsset, theService *components.Service) {
 				delay := 1 * time.Second
 				for {
-					timer := time.NewTimer(delay)
-					mutex.RLock()
-					regURL := leadRegistrarURL
-					mutex.RUnlock()
 					select {
-					case <-timer.C:
-						delay = registerService(sys, regURL, theUnitAsset, theService)
+					case <-time.Tick(delay):
+						delay = registerService(sys, registrar.get(), theUnitAsset, theService)
 					case <-sys.Ctx.Done():
-						err := unregisterService(regURL, theService)
+						err := unregisterService(registrar.get(), theService)
 						if err != nil {
 							log.Println("unregistering service:", err)
 						}

From 8b2f6f2b8e9c0aca3c9736ecc683d526506c343c Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 26 Jun 2025 09:25:22 +0200
Subject: [PATCH 107/186] Cleans up error handling and var names

---
 usecases/service_discovery.go | 32 +++++++++++++++-----------------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/usecases/service_discovery.go b/usecases/service_discovery.go
index 9c1f01d..43ccdcf 100644
--- a/usecases/service_discovery.go
+++ b/usecases/service_discovery.go
@@ -95,17 +95,17 @@ func sendHttpReq(method string, url string, data []byte) (resp *http.Response, e
 // Search4Service requests from the core systems the address of resources's services that meet the need
 func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocation forms.ServicePoint_v1, err error) {
 	// Create a new HTTP request to the Orchestrator system (for now the Service Registrar)
-	orchestratorPointer, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
+	orURL, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
 	if err != nil {
 		return servLocation, err
 	}
 	// prepare the payload to perform a service quest
-	oURL := orchestratorPointer + "/squest"
+	orURL = orURL + "/squest"
 	jsonQF, err := json.MarshalIndent(qf, "", "  ")
 	if err != nil {
 		return servLocation, err
 	}
-	resp, err := sendHttpReq(http.MethodPost, oURL, jsonQF)
+	resp, err := sendHttpReq(http.MethodPost, orURL, jsonQF)
 	if err != nil {
 		return servLocation, err
 	}
@@ -139,19 +139,18 @@ func Search4Services(cer *components.Cervice, sys *components.System) (err error
 		return err
 	}
 	// Search for an Orchestrator system within the local cloud
-	orchestratorPointer, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
+	orURL, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
 	if err != nil {
 		return err
 	}
-	if orchestratorPointer == "" {
-		err = fmt.Errorf("failed to locate an Orchestrator")
-		return err
+	if orURL == "" {
+		return fmt.Errorf("failed to locate an orchestrator")
 	}
-	oURL := orchestratorPointer + "/squest"
-	// Prepare the request to the Orchestrator
-	resp, err := sendHttpReq(http.MethodPost, oURL, qf)
+	orURL = orURL + "/squest"
+	// Prepare the request to the orchestrator
+	resp, err := sendHttpReq(http.MethodPost, orURL, qf)
 	if err != nil {
-		return
+		return err
 	}
 	defer resp.Body.Close()
 	// Read the response /////////////////////////////////
@@ -159,19 +158,18 @@ func Search4Services(cer *components.Cervice, sys *components.System) (err error
 	if err != nil {
 		return err
 	}
-	headerContentTtype := resp.Header.Get("Content-Type")
-	discoveryForm, err := Unpack(bodyBytes, headerContentTtype)
+	headerContentType := resp.Header.Get("Content-Type")
+	discoveryForm, err := Unpack(bodyBytes, headerContentType)
 	if err != nil {
-		log.Printf("error extracting the discovery request %v\n", err)
+		return err
 	}
 	// Perform a type assertion to convert the returned Form to ServicePoint_v1
 	df, ok := discoveryForm.(*forms.ServicePoint_v1)
 	if !ok {
-		fmt.Println("Problem unpacking the service discovery request form")
-		return
+		return fmt.Errorf("unable to unpack discovery request form")
 	}
 	cer.Nodes[df.ServNode] = append(cer.Nodes[df.ServNode], df.ServLocation)
-	return err
+	return nil
 }
 
 // FillDiscoveredServices returns a json data byte array with a slice of matching services (e.g., Service Registrar)

From c0e94a8b3a2dc1c83ce7823f62acb392ec367090 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 26 Jun 2025 09:25:22 +0200
Subject: [PATCH 108/186] Adds tests for service registration

---
 tests/integration_test.go | 189 ++++++++++++++++++++++++++++++++++----
 1 file changed, 173 insertions(+), 16 deletions(-)

diff --git a/tests/integration_test.go b/tests/integration_test.go
index 32e8862..297d3c0 100644
--- a/tests/integration_test.go
+++ b/tests/integration_test.go
@@ -4,19 +4,24 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"os"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/forms"
 	"github.com/sdoque/mbaigo/usecases"
 )
 
+////////////////////////////////////////////////////////////////////////////////
+// The most simplest unit asset
+
 // Force type check (fulfilling the interface) at compile time
 var _ components.UnitAsset = &uaGreeter{}
 
-// The most simplistic UnitAsset possible
 type uaGreeter struct {
 	Name        string              `json:"-"`
 	Owner       *components.System  `json:"-"`
@@ -45,7 +50,7 @@ func addGreeterTemplate(sys *components.System) {
 	greetService := &components.Service{
 		Definition: "greet", // The "name" of the service
 		SubPath:    "greet", // Not "allowed" to be changed afterwards
-		Details:    map[string][]string{"key": []string{"value"}},
+		Details:    map[string][]string{"key1": {"value1"}},
 		RegPeriod:  60,
 		// NOTE: must start with lower-case, it gets embedded into another sentence in the web API
 		Description: "greets you with a message",
@@ -53,7 +58,7 @@ func addGreeterTemplate(sys *components.System) {
 	var ua components.UnitAsset
 	ua = &uaGreeter{
 		Name:    "greeter", // WARN: don't use the system name!! this is an asset!
-		Details: map[string][]string{"key": {"value"}},
+		Details: map[string][]string{"key2": {"value2"}},
 		ServicesMap: components.Services{
 			greetService.SubPath: greetService,
 		},
@@ -62,16 +67,25 @@ func addGreeterTemplate(sys *components.System) {
 }
 
 func loadGreeter(ca usecases.ConfigurableAsset, sys *components.System) (components.UnitAsset, func()) {
+	service := ca.Services[0]
 	ua := &uaGreeter{
 		Name:        ca.Name,
 		Owner:       sys,
 		Details:     ca.Details,
 		ServicesMap: usecases.MakeServiceMap(ca.Services),
+		// Let it consume its own service
+		CervicesMap: components.Cervices{ca.Name: &components.Cervice{
+			Definition: service.Definition,
+			Details:    service.Details,
+			// TODO: need nodes map?? doesn't look like it so far
+		}},
 	}
 	return ua, func() {}
 }
 
-// Creates the most simplest system possible
+////////////////////////////////////////////////////////////////////////////////
+// The most simplest system
+
 func newSystem() (*components.System, func(), error) {
 	ctx, cancel := context.WithCancel(context.Background())
 
@@ -79,19 +93,29 @@ func newSystem() (*components.System, func(), error) {
 	sys := components.NewSystem("test", ctx)
 	sys.Husk = &components.Husk{
 		Description: " is the most simplest system possible, used for performing integration tests",
-		Details:     map[string][]string{"key": {"value"}},
+		Details:     map[string][]string{"key3": {"value3"}},
 		ProtoPort:   map[string]int{"http": 29999},
 	}
 
 	addGreeterTemplate(&sys)
 	rawResources, err := usecases.Configure(&sys)
 	if err != nil {
-		// TODO: check for ErrCreatedConfig blah, if so continue
-		cancel()
-		return nil, nil, err
+		// TODO: once configuration PR is merged, check for ErrCreatedConfig blah instead
+		if !strings.Contains(err.Error(), "a new configuration file") {
+			cancel()
+			return nil, nil, err
+		}
+		// Since Configure() created the config file, it must be cleaned up when this test is done!
+		defer os.Remove("systemconfig.json")
+		// Default config file was created, redo the func call to load the file
+		rawResources, err = usecases.Configure(&sys)
+		if err != nil {
+			cancel()
+			return nil, nil, err
+		}
 	}
-	// Don't leave any leftovers, no matter what
-	defer os.Remove("systemconfig.json")
+	// NOTE: if the config file already existed (thus the above error block didn't
+	// get to run), then the config file should be left alone and not removed!
 
 	// TODO: this could had been done already in Configure()?
 	// But that would need a change in the function signature
@@ -108,24 +132,23 @@ func newSystem() (*components.System, func(), error) {
 	usecases.RegisterServices(&sys)
 
 	// TODO: prints logs??
-	go usecases.SetoutServers(&sys)
+	usecases.SetoutServers(&sys)
 
 	stop := func() {
 		cancel()
-		// TODO: this should be replaced with a wait group instead
-		time.Sleep(2 * time.Second)
+		// TODO: a waitgroup or something should be used to make sure all goroutines have stopped
+		// Not doing much in the mock cleanups so this works fine for now...?
 		cleanups()
 	}
 	return &sys, stop, nil
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// PROPOSAL: new additions to usecases/configuration.go?
 
-// TODO: move to usecases/configure
 // TODO: this function really needs an error return too
 type NewResourceFunc func(usecases.ConfigurableAsset, *components.System) (components.UnitAsset, func())
 
-// TODO: move to usecases/configure
 func LoadResources(sys *components.System, rawRes []json.RawMessage, newRes NewResourceFunc) (func(), error) {
 	// Resets this map so it can be filled with loaded unit assets (rather than templates)
 	sys.UAssets = make(map[string]*components.UnitAsset)
@@ -152,9 +175,143 @@ func LoadResources(sys *components.System, rawRes []json.RawMessage, newRes NewR
 
 ////////////////////////////////////////////////////////////////////////////////
 
+type mockTrans struct {
+	t      *testing.T
+	hits   map[string]int // Used to track http requests
+	events chan string    // Allows waiting for requests
+}
+
+func newMockTransport(t *testing.T) *mockTrans {
+	m := &mockTrans{
+		t:      t,
+		hits:   make(map[string]int),
+		events: make(chan string),
+	}
+	// Hijack the default http client so no actual http requests are sent over the network
+	http.DefaultClient.Transport = m
+	return m
+}
+
+func (m *mockTrans) waitFor(event string) error {
+	select {
+	case e := <-m.events:
+		if e != event {
+			return fmt.Errorf("got %s, expected %s", e, event)
+		}
+		return nil
+	case <-time.Tick(10 * time.Second):
+		return fmt.Errorf("event timeout")
+	}
+}
+
+func newServiceRecord() (b []byte, err error) {
+	f := forms.ServiceRecord_v1{
+		Id:            13,
+		Created:       time.Now().Format(time.RFC3339),
+		EndOfValidity: time.Now().Format(time.RFC3339),
+		Version:       "ServiceRecord_v1",
+	}
+	return usecases.Pack(&f, "application/json")
+}
+
+const eventRegistryStatus string = "GET /serviceregistrar/registry/status"
+const eventRegister string = "POST /serviceregistrar/registry/register"
+const eventUnregister string = "DELETE /serviceregistrar/registry/unregister/13"
+
+func (m *mockTrans) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	status, body := 200, ""
+	key := req.Method + " " + req.URL.Path
+	m.hits[key] += 1
+	switch key {
+
+	// Find leading registrar
+	case eventRegistryStatus:
+		status, body = 200, components.ServiceRegistrarLeader
+
+	// Register services with registrar
+	case eventRegister:
+		// TODO: validate body
+		// b, err := io.ReadAll(req.Body)
+		// if err != nil {
+		// 	return nil, err
+		// }
+		// defer req.Body.Close()
+		// fmt.Println(string(b))
+		f, err := newServiceRecord()
+		if err != nil {
+			m.t.Fatalf("newServiceRecord: %s", err)
+		}
+		m.events <- key
+		status, body = 200, string(f)
+
+	// Unregister services
+	case eventUnregister:
+		// TODO: validate the id matches with id in the form sent above
+		m.events <- key
+
+	// TODO handle orchestrator requests
+
+	default:
+		m.t.Errorf("unknown request: %s", key)
+	}
+
+	resp = &http.Response{
+		StatusCode:    status,
+		Status:        http.StatusText(status),
+		Body:          io.NopCloser(strings.NewReader(body)),
+		ContentLength: int64(len(body)),
+		Request:       req,
+		Header: map[string][]string{
+			"Content-Type": {"application/json"},
+		},
+	}
+	return resp, nil
+}
+
 func TestSimpleSystemIntegration(t *testing.T) {
+	m := newMockTransport(t)
 	sys, stop, err := newSystem()
 	if err != nil {
-		panic(err) // TODO
+		t.Fatalf("expected no error, got: %s", err)
+	}
+	// TODO: try grabbing the ua in some cleaner way
+	var ua components.UnitAsset
+	for _, v := range sys.UAssets {
+		ua = *v
+		break
+	}
+	if ua == nil {
+		t.Fatal("missing unit asset in service")
+	}
+
+	// Validate service registration
+	if err = m.waitFor(eventRegister); err != nil {
+		t.Fatal(err)
+	}
+	// This status check occurs so many times so can't assume we only hit it once
+	if m.hits[eventRegistryStatus] < 1 {
+		t.Errorf("system skipped: %s", eventRegistryStatus)
+	}
+	if m.hits[eventRegister] != 1 {
+		t.Errorf("system skipped: %s", eventRegister)
+	}
+
+	// Validate service use
+	service := ua.GetCervices()[ua.GetName()]
+	if service == nil {
+		t.Fatalf("unit asset missing cervice: %s", ua.GetName())
+	}
+	f, err := usecases.GetState(service, sys)
+	if err != nil {
+		t.Errorf("%s", err)
+	}
+	// TODO: validate return form
+	fmt.Println(f)
+
+	// Validate service unregister
+	stop()
+	m.waitFor(eventUnregister)
+	if m.hits[eventUnregister] != 1 {
+		t.Errorf("system skipped: %s", eventUnregister)
 	}
 }

From 60ca78f2b52e2aa76f0b7a7959c724c5dfb60579 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 29 Jun 2025 14:00:07 +0200
Subject: [PATCH 109/186] Cleans up http server shutdown

http.Server.Shutdown() should be given a non-closed
context without errors, so any idle connections gets
the chance to finish properly.

Also removed the delay before shutdown, now that the
http server has a chance to finish its connections too.
---
 usecases/servers_handlers.go | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/usecases/servers_handlers.go b/usecases/servers_handlers.go
index 1d09783..6fb74c8 100644
--- a/usecases/servers_handlers.go
+++ b/usecases/servers_handlers.go
@@ -22,6 +22,7 @@
 package usecases
 
 import (
+	"context"
 	"crypto/ecdsa"
 	"crypto/tls"
 	"crypto/x509"
@@ -87,9 +88,7 @@ func SetoutServers(sys *components.System) error {
 		// Initiate graceful shutdown on signal reception
 		go func() {
 			<-sys.Ctx.Done()
-			time.Sleep(1 * time.Second) // this line is for the leading service registrar to deregister its own services
-			// log.Printf("Initiating graceful shutdown of the HTTPS server.\n")
-			if err := httpsServer.Shutdown(sys.Ctx); err != nil {
+			if err := httpsServer.Shutdown(context.Background()); err != nil {
 				log.Printf("Error during shutdown: %v", err)
 			}
 		}()
@@ -120,9 +119,7 @@ func SetoutServers(sys *components.System) error {
 		// Initiate graceful shutdown on signal reception
 		go func() {
 			<-sys.Ctx.Done()
-			time.Sleep(1 * time.Second) // this line is for the leading service registrar to deregister its own services
-			// log.Printf("Initiating graceful shutdown of the HTTP server.\n")
-			if err := httpServer.Shutdown(sys.Ctx); err != nil {
+			if err := httpServer.Shutdown(context.Background()); err != nil {
 				log.Printf("Error during shutdown: %v", err)
 			}
 		}()

From 0084ad2400e6974dc4c0a13370aabc7d15199b2f Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 29 Jun 2025 14:00:07 +0200
Subject: [PATCH 110/186] Detect leaking goroutines

---
 tests/integration_test.go | 42 ++++++++++++++++++++++++++++++++++++---
 1 file changed, 39 insertions(+), 3 deletions(-)

diff --git a/tests/integration_test.go b/tests/integration_test.go
index 297d3c0..9586398 100644
--- a/tests/integration_test.go
+++ b/tests/integration_test.go
@@ -1,12 +1,16 @@
 package tests
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
+	"os/signal"
+	"runtime"
+	"runtime/pprof"
 	"strings"
 	"testing"
 	"time"
@@ -55,14 +59,13 @@ func addGreeterTemplate(sys *components.System) {
 		// NOTE: must start with lower-case, it gets embedded into another sentence in the web API
 		Description: "greets you with a message",
 	}
-	var ua components.UnitAsset
-	ua = &uaGreeter{
+	ua := components.UnitAsset(&uaGreeter{
 		Name:    "greeter", // WARN: don't use the system name!! this is an asset!
 		Details: map[string][]string{"key2": {"value2"}},
 		ServicesMap: components.Services{
 			greetService.SubPath: greetService,
 		},
-	}
+	})
 	sys.UAssets[ua.GetName()] = &ua
 }
 
@@ -169,6 +172,9 @@ func LoadResources(sys *components.System, rawRes []json.RawMessage, newRes NewR
 		for _, f := range cleanups {
 			f()
 		}
+		// Stops hijacking SIGINT and return signal control to user
+		signal.Stop(sys.Sigs)
+		close(sys.Sigs)
 	}
 	return doCleanups, nil
 }
@@ -268,7 +274,26 @@ func (m *mockTrans) RoundTrip(req *http.Request) (resp *http.Response, err error
 	return resp, nil
 }
 
+func countGoroutines() (int, string) {
+	c := runtime.NumGoroutine()
+	buf := &bytes.Buffer{}
+	// A write to this buffer will always return nil error, so safe to ignore here.
+	// This call will spawn some goroutine too, so need to chill for a little while.
+	_ = pprof.Lookup("goroutine").WriteTo(buf, 2)
+	trace := buf.String()
+	// Calling signal.Notify() will leave an extra goroutine that runs forever,
+	// so it should be subtracted from the count. For more info, see:
+	// https://github.com/golang/go/issues/52619
+	// https://github.com/golang/go/issues/72803
+	// https://github.com/golang/go/issues/21576
+	if strings.Contains(trace, "os/signal.signal_recv") {
+		c -= 1
+	}
+	return c, trace
+}
+
 func TestSimpleSystemIntegration(t *testing.T) {
+	routinesStart, _ := countGoroutines()
 	m := newMockTransport(t)
 	sys, stop, err := newSystem()
 	if err != nil {
@@ -314,4 +339,15 @@ func TestSimpleSystemIntegration(t *testing.T) {
 	if m.hits[eventUnregister] != 1 {
 		t.Errorf("system skipped: %s", eventUnregister)
 	}
+
+	// Detect any leaking goroutines
+	// Delay a short moment and let the goroutines finish. Not sure if there's
+	// a better way to wait for an unknown number of goroutines.
+	time.Sleep(1 * time.Second)
+	routinesStop, trace := countGoroutines()
+	if (routinesStop - routinesStart) != 0 {
+		t.Errorf("leaking goroutines, count at start=%d, stop=%d\n%s",
+			routinesStart, routinesStop, trace,
+		)
+	}
 }

From a4cde2c3ba82ea2865f7c3c3b0ee42c18ac280b6 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 29 Jun 2025 18:31:03 +0200
Subject: [PATCH 111/186] Fixes misspelled json tag

---
 forms/servicequest_forms.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/forms/servicequest_forms.go b/forms/servicequest_forms.go
index 79603a9..f3dee27 100644
--- a/forms/servicequest_forms.go
+++ b/forms/servicequest_forms.go
@@ -30,7 +30,7 @@ import "reflect"
 type ServiceQuest_v1 struct {
 	SysId             int                 `json:"systemId"`
 	RequesterName     string              `json:"requesterName"`
-	ServiceDefinition string              `json:"serrviceDefinition"`
+	ServiceDefinition string              `json:"serviceDefinition"`
 	Protocol          string              `json:"protocol"`
 	Details           map[string][]string `json:"details"`
 	Version           string              `json:"version"`

From 5af95010e66d0b559e6275e118b8921ea807e3d5 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 29 Jun 2025 18:31:03 +0200
Subject: [PATCH 112/186] Fixes some error messages

---
 usecases/consumption.go       | 2 +-
 usecases/service_discovery.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index b8e5bb6..8f5ac96 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -69,7 +69,7 @@ func stateHandler(httpMethod string, cer *components.Cervice, sys *components.Sy
 	}
 
 	if len(bodyBytes) < 1 {
-		return f, fmt.Errorf("got empty response body: %w", err)
+		return f, fmt.Errorf("got empty response body")
 
 	}
 
diff --git a/usecases/service_discovery.go b/usecases/service_discovery.go
index 43ccdcf..3240ab9 100644
--- a/usecases/service_discovery.go
+++ b/usecases/service_discovery.go
@@ -87,7 +87,7 @@ func sendHttpReq(method string, url string, data []byte) (resp *http.Response, e
 		return nil, err
 	}
 	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return resp, fmt.Errorf("received non-2xx status code: %d, response: %s from the Orchestrator", resp.StatusCode, http.StatusText(resp.StatusCode))
+		return nil, fmt.Errorf("bad response: %d %s", resp.StatusCode, resp.Status)
 	}
 	return
 }

From 210028c070338e5e47ae009b4629a78480d4eb92 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sun, 29 Jun 2025 18:31:03 +0200
Subject: [PATCH 113/186] Adds orchestrator mocks and cleanups

---
 tests/integration_test.go | 245 ++++++++++++++++++++++++--------------
 1 file changed, 156 insertions(+), 89 deletions(-)

diff --git a/tests/integration_test.go b/tests/integration_test.go
index 9586398..a399b91 100644
--- a/tests/integration_test.go
+++ b/tests/integration_test.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"math/rand/v2"
 	"net/http"
 	"os"
 	"os/signal"
@@ -23,64 +24,77 @@ import (
 ////////////////////////////////////////////////////////////////////////////////
 // The most simplest unit asset
 
+const (
+	unitName    string = "randomiser"
+	unitService string = "random"
+)
+
 // Force type check (fulfilling the interface) at compile time
-var _ components.UnitAsset = &uaGreeter{}
+var _ components.UnitAsset = &uaRandomiser{}
 
-type uaGreeter struct {
+type uaRandomiser struct {
 	Name        string              `json:"-"`
 	Owner       *components.System  `json:"-"`
 	Details     map[string][]string `json:"-"`
 	ServicesMap components.Services `json:"-"`
 	CervicesMap components.Cervices `json:"-"`
-	greeting    string
 }
 
 // Add required functions to fulfil the UnitAsset interface
-func (ua uaGreeter) GetName() string                  { return ua.Name }
-func (ua uaGreeter) GetServices() components.Services { return ua.ServicesMap }
-func (ua uaGreeter) GetCervices() components.Cervices { return ua.CervicesMap }
-func (ua uaGreeter) GetDetails() map[string][]string  { return ua.Details }
-func (ua uaGreeter) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
-	if servicePath != "greet" {
+func (ua uaRandomiser) GetName() string                  { return ua.Name }
+func (ua uaRandomiser) GetServices() components.Services { return ua.ServicesMap }
+func (ua uaRandomiser) GetCervices() components.Cervices { return ua.CervicesMap }
+func (ua uaRandomiser) GetDetails() map[string][]string  { return ua.Details }
+func (ua uaRandomiser) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
+	if servicePath != unitService {
 		http.Error(w, "unknown service path: "+servicePath, http.StatusBadRequest)
 		return
 	}
-	if _, err := fmt.Fprintln(w, ua.greeting); err != nil {
-		http.Error(w, "error while writing greeting: "+err.Error(), http.StatusInternalServerError)
+	f := forms.SignalA_v1a{
+		Value: rand.Float64(),
+	}
+	b, err := usecases.Pack(f.NewForm(), "application/json")
+	if err != nil {
+		http.Error(w, "error from Pack: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if _, err := w.Write(b); err != nil {
+		http.Error(w, "error from Write: "+err.Error(), http.StatusInternalServerError)
 	}
 }
 
-func addGreeterTemplate(sys *components.System) {
-	greetService := &components.Service{
-		Definition: "greet", // The "name" of the service
-		SubPath:    "greet", // Not "allowed" to be changed afterwards
+func addUATemplate(sys *components.System) {
+	s := &components.Service{
+		Definition: unitService, // The "name" of the service
+		SubPath:    unitService, // Not "allowed" to be changed afterwards
 		Details:    map[string][]string{"key1": {"value1"}},
 		RegPeriod:  60,
 		// NOTE: must start with lower-case, it gets embedded into another sentence in the web API
-		Description: "greets you with a message",
+		Description: "returns a random float64",
 	}
-	ua := components.UnitAsset(&uaGreeter{
-		Name:    "greeter", // WARN: don't use the system name!! this is an asset!
+	ua := components.UnitAsset(&uaRandomiser{
+		Name:    unitName, // WARN: don't use the system name!! this is an asset!
 		Details: map[string][]string{"key2": {"value2"}},
 		ServicesMap: components.Services{
-			greetService.SubPath: greetService,
+			s.SubPath: s,
 		},
 	})
 	sys.UAssets[ua.GetName()] = &ua
 }
 
-func loadGreeter(ca usecases.ConfigurableAsset, sys *components.System) (components.UnitAsset, func()) {
-	service := ca.Services[0]
-	ua := &uaGreeter{
+func loadUA(ca usecases.ConfigurableAsset, sys *components.System) (components.UnitAsset, func()) {
+	s := ca.Services[0]
+	ua := &uaRandomiser{
 		Name:        ca.Name,
 		Owner:       sys,
 		Details:     ca.Details,
 		ServicesMap: usecases.MakeServiceMap(ca.Services),
 		// Let it consume its own service
-		CervicesMap: components.Cervices{ca.Name: &components.Cervice{
-			Definition: service.Definition,
-			Details:    service.Details,
-			// TODO: need nodes map?? doesn't look like it so far
+		CervicesMap: components.Cervices{unitService: &components.Cervice{
+			Definition: s.Definition,
+			Details:    s.Details,
+			// Nodes will be filled up by any discovered cervices
+			Nodes: make(map[string][]string, 0),
 		}},
 	}
 	return ua, func() {}
@@ -89,19 +103,25 @@ func loadGreeter(ca usecases.ConfigurableAsset, sys *components.System) (compone
 ////////////////////////////////////////////////////////////////////////////////
 // The most simplest system
 
+const systemName string = "test"
+
 func newSystem() (*components.System, func(), error) {
 	ctx, cancel := context.WithCancel(context.Background())
 
-	// TODO: want this to return a pointer type instead! easier to use and pointer is used all the time anyway down below
-	sys := components.NewSystem("test", ctx)
+	// TODO: want this to return a pointer type instead!
+	// easier to use and pointer is used all the time anyway down below
+	sys := components.NewSystem(systemName, ctx)
 	sys.Husk = &components.Husk{
-		Description: " is the most simplest system possible, used for performing integration tests",
+		Description: " is the most simplest system possible",
 		Details:     map[string][]string{"key3": {"value3"}},
 		ProtoPort:   map[string]int{"http": 29999},
 	}
 
-	addGreeterTemplate(&sys)
+	// Setup default config with default unit asset and values
+	addUATemplate(&sys)
 	rawResources, err := usecases.Configure(&sys)
+
+	// Extra check to work around "created config" error. Not required normally!
 	if err != nil {
 		// TODO: once configuration PR is merged, check for ErrCreatedConfig blah instead
 		if !strings.Contains(err.Error(), "a new configuration file") {
@@ -120,9 +140,8 @@ func newSystem() (*components.System, func(), error) {
 	// NOTE: if the config file already existed (thus the above error block didn't
 	// get to run), then the config file should be left alone and not removed!
 
-	// TODO: this could had been done already in Configure()?
-	// But that would need a change in the function signature
-	cleanups, err := LoadResources(&sys, rawResources, loadGreeter)
+	// Load unit assets defined in the config file
+	cleanups, err := LoadResources(&sys, rawResources, loadUA)
 	if err != nil {
 		cancel()
 		return nil, nil, err
@@ -181,38 +200,53 @@ func LoadResources(sys *components.System, rawRes []json.RawMessage, newRes NewR
 
 ////////////////////////////////////////////////////////////////////////////////
 
+type event struct {
+	key  string
+	hits int
+}
+
 type mockTrans struct {
 	t      *testing.T
 	hits   map[string]int // Used to track http requests
-	events chan string    // Allows waiting for requests
+	events chan event
+	sys    *components.System
+	ua     components.UnitAsset
 }
 
 func newMockTransport(t *testing.T) *mockTrans {
 	m := &mockTrans{
 		t:      t,
 		hits:   make(map[string]int),
-		events: make(chan string),
+		events: make(chan event),
 	}
 	// Hijack the default http client so no actual http requests are sent over the network
 	http.DefaultClient.Transport = m
 	return m
 }
 
-func (m *mockTrans) waitFor(event string) error {
+func (m *mockTrans) trackSystem(s *components.System) {
+	m.sys = s
+	m.ua = *s.UAssets[unitName]
+	if m.ua == nil {
+		m.t.Fatalf("missing unit asset %s in system %s", unitName, systemName)
+	}
+}
+
+func (m *mockTrans) waitFor(event string) (int, error) {
 	select {
 	case e := <-m.events:
-		if e != event {
-			return fmt.Errorf("got %s, expected %s", e, event)
+		if e.key != event {
+			return 0, fmt.Errorf("got %s, expected %s", e.key, event)
 		}
-		return nil
+		return e.hits, nil
 	case <-time.Tick(10 * time.Second):
-		return fmt.Errorf("event timeout")
+		return 0, fmt.Errorf("event timeout")
 	}
 }
 
-func newServiceRecord() (b []byte, err error) {
+func (m *mockTrans) newServiceRecord() (b []byte, err error) {
 	f := forms.ServiceRecord_v1{
-		Id:            13,
+		Id:            13, // NOTE: this should match with eventUnregister
 		Created:       time.Now().Format(time.RFC3339),
 		EndOfValidity: time.Now().Format(time.RFC3339),
 		Version:       "ServiceRecord_v1",
@@ -220,19 +254,42 @@ func newServiceRecord() (b []byte, err error) {
 	return usecases.Pack(&f, "application/json")
 }
 
-const eventRegistryStatus string = "GET /serviceregistrar/registry/status"
-const eventRegister string = "POST /serviceregistrar/registry/register"
-const eventUnregister string = "DELETE /serviceregistrar/registry/unregister/13"
+func (m *mockTrans) newServicePoint() (b []byte, err error) {
+	f := forms.ServicePoint_v1{
+		// per usecases/registration.go:serviceRegistrationForm()
+		ServNode: fmt.Sprintf("localhost_%s_%s_%s", systemName, unitName, unitService),
+		// per orchestrator/thing.go:selectService()
+		ServLocation: fmt.Sprintf("http://localhost:%d/%s/%s/%s",
+			m.sys.Husk.ProtoPort["http"], systemName, unitName, unitService,
+		),
+		Version: "ServicePoint_v1",
+	}
+	return usecases.Pack(&f, "application/json")
+}
+
+const (
+	eventRegistryStatus string = "GET /serviceregistrar/registry/status"
+	eventRegister       string = "POST /serviceregistrar/registry/register"
+	eventUnregister     string = "DELETE /serviceregistrar/registry/unregister/13"
+	eventOrchestration  string = "GET /orchestrator/orchestration"
+	eventOrchestrate    string = "POST /orchestrator/orchestration/squest"
+)
 
-func (m *mockTrans) RoundTrip(req *http.Request) (resp *http.Response, err error) {
-	status, body := 200, ""
-	key := req.Method + " " + req.URL.Path
+func (m *mockTrans) RoundTrip(req *http.Request) (*http.Response, error) {
+	resp := &http.Response{
+		StatusCode: http.StatusNotImplemented,
+		Request:    req,
+		Header: map[string][]string{
+			"Content-Type": {"application/json"},
+		},
+	}
+	body, key := "", req.Method+" "+req.URL.Path
 	m.hits[key] += 1
 	switch key {
 
 	// Find leading registrar
 	case eventRegistryStatus:
-		status, body = 200, components.ServiceRegistrarLeader
+		resp.StatusCode, body = 200, components.ServiceRegistrarLeader
 
 	// Register services with registrar
 	case eventRegister:
@@ -243,33 +300,49 @@ func (m *mockTrans) RoundTrip(req *http.Request) (resp *http.Response, err error
 		// }
 		// defer req.Body.Close()
 		// fmt.Println(string(b))
-		f, err := newServiceRecord()
+		f, err := m.newServiceRecord()
 		if err != nil {
-			m.t.Fatalf("newServiceRecord: %s", err)
+			return nil, err
 		}
-		m.events <- key
-		status, body = 200, string(f)
+		m.events <- event{key, m.hits[key]}
+		resp.StatusCode, body = 200, string(f)
 
 	// Unregister services
 	case eventUnregister:
-		// TODO: validate the id matches with id in the form sent above
-		m.events <- key
+		m.events <- event{key, m.hits[key]}
+
+	case eventOrchestration:
+		resp.StatusCode = 200
 
-	// TODO handle orchestrator requests
+	case eventOrchestrate:
+		// TODO: validate body
+		// b, err := io.ReadAll(req.Body)
+		// if err != nil {
+		// 	return nil, err
+		// }
+		// defer req.Body.Close()
+		// fmt.Println(string(b))
+		f, err := m.newServicePoint()
+		if err != nil {
+			return nil, err
+		}
+		resp.StatusCode, body = 200, string(f)
+
+	case fmt.Sprintf("GET /%s/%s/%s", systemName, unitName, unitService):
+		var err error
+		resp, err = http.DefaultTransport.RoundTrip(req)
+		if err != nil {
+			return nil, err
+		}
 
 	default:
 		m.t.Errorf("unknown request: %s", key)
 	}
 
-	resp = &http.Response{
-		StatusCode:    status,
-		Status:        http.StatusText(status),
-		Body:          io.NopCloser(strings.NewReader(body)),
-		ContentLength: int64(len(body)),
-		Request:       req,
-		Header: map[string][]string{
-			"Content-Type": {"application/json"},
-		},
+	resp.Status = http.StatusText(resp.StatusCode)
+	if len(body) > 0 {
+		resp.Body = io.NopCloser(strings.NewReader(body))
+		resp.ContentLength = int64(len(body))
 	}
 	return resp, nil
 }
@@ -299,54 +372,48 @@ func TestSimpleSystemIntegration(t *testing.T) {
 	if err != nil {
 		t.Fatalf("expected no error, got: %s", err)
 	}
-	// TODO: try grabbing the ua in some cleaner way
-	var ua components.UnitAsset
-	for _, v := range sys.UAssets {
-		ua = *v
-		break
-	}
-	if ua == nil {
-		t.Fatal("missing unit asset in service")
-	}
+	m.trackSystem(sys)
 
 	// Validate service registration
-	if err = m.waitFor(eventRegister); err != nil {
+	hits, err := m.waitFor(eventRegister)
+	if err != nil {
 		t.Fatal(err)
 	}
-	// This status check occurs so many times so can't assume we only hit it once
-	if m.hits[eventRegistryStatus] < 1 {
-		t.Errorf("system skipped: %s", eventRegistryStatus)
-	}
-	if m.hits[eventRegister] != 1 {
+	if hits != 1 {
 		t.Errorf("system skipped: %s", eventRegister)
 	}
 
 	// Validate service use
-	service := ua.GetCervices()[ua.GetName()]
+	service := m.ua.GetCervices()[unitService]
 	if service == nil {
-		t.Fatalf("unit asset missing cervice: %s", ua.GetName())
+		t.Fatalf("unit asset missing cervice: %s", unitService)
 	}
 	f, err := usecases.GetState(service, sys)
 	if err != nil {
-		t.Errorf("%s", err)
+		t.Errorf("error from GetState: %s", err)
+	}
+	fs, ok := f.(*forms.SignalA_v1a)
+	if ok == false || fs == nil || fs.Value == 0.0 {
+		t.Errorf("invalid form: %#v", f)
 	}
-	// TODO: validate return form
-	fmt.Println(f)
 
 	// Validate service unregister
 	stop()
-	m.waitFor(eventUnregister)
-	if m.hits[eventUnregister] != 1 {
+	hits, err = m.waitFor(eventUnregister)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hits != 1 {
 		t.Errorf("system skipped: %s", eventUnregister)
 	}
 
 	// Detect any leaking goroutines
 	// Delay a short moment and let the goroutines finish. Not sure if there's
-	// a better way to wait for an unknown number of goroutines.
+	// a better way to wait for an _unknown number_ of goroutines.
 	time.Sleep(1 * time.Second)
 	routinesStop, trace := countGoroutines()
 	if (routinesStop - routinesStart) != 0 {
-		t.Errorf("leaking goroutines, count at start=%d, stop=%d\n%s",
+		t.Errorf("leaking goroutines: count at start=%d, stop=%d\n%s",
 			routinesStart, routinesStop, trace,
 		)
 	}

From f7e789a7e3d575177a3ad26c1478e38ddd7ce135 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Tue, 1 Jul 2025 15:48:52 +0200
Subject: [PATCH 114/186] Refactors the mock and adds extra data checks

---
 tests/integration_test.go | 217 ++++++++++++++++++++------------------
 1 file changed, 115 insertions(+), 102 deletions(-)

diff --git a/tests/integration_test.go b/tests/integration_test.go
index a399b91..fa862f7 100644
--- a/tests/integration_test.go
+++ b/tests/integration_test.go
@@ -8,11 +8,14 @@ import (
 	"io"
 	"math/rand/v2"
 	"net/http"
+	"net/http/httptest"
 	"os"
 	"os/signal"
+	"path"
 	"runtime"
 	"runtime/pprof"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -103,7 +106,12 @@ func loadUA(ca usecases.ConfigurableAsset, sys *components.System) (components.U
 ////////////////////////////////////////////////////////////////////////////////
 // The most simplest system
 
-const systemName string = "test"
+const (
+	systemName string = "test"
+	systemPort int    = 29999
+)
+
+var serviceURL = "GET /" + path.Join(systemName, unitName, unitService)
 
 func newSystem() (*components.System, func(), error) {
 	ctx, cancel := context.WithCancel(context.Background())
@@ -114,7 +122,7 @@ func newSystem() (*components.System, func(), error) {
 	sys.Husk = &components.Husk{
 		Description: " is the most simplest system possible",
 		Details:     map[string][]string{"key3": {"value3"}},
-		ProtoPort:   map[string]int{"http": 29999},
+		ProtoPort:   map[string]int{"http": systemPort},
 	}
 
 	// Setup default config with default unit asset and values
@@ -199,18 +207,19 @@ func LoadResources(sys *components.System, rawRes []json.RawMessage, newRes NewR
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Mock simulating traffic between a system and registrars/orchestrators
 
 type event struct {
 	key  string
 	hits int
+	body []byte
 }
 
 type mockTrans struct {
 	t      *testing.T
 	hits   map[string]int // Used to track http requests
+	mutex  sync.Mutex     // For protecting access to the above map
 	events chan event
-	sys    *components.System
-	ua     components.UnitAsset
 }
 
 func newMockTransport(t *testing.T) *mockTrans {
@@ -224,47 +233,47 @@ func newMockTransport(t *testing.T) *mockTrans {
 	return m
 }
 
-func (m *mockTrans) trackSystem(s *components.System) {
-	m.sys = s
-	m.ua = *s.UAssets[unitName]
-	if m.ua == nil {
-		m.t.Fatalf("missing unit asset %s in system %s", unitName, systemName)
-	}
-}
-
-func (m *mockTrans) waitFor(event string) (int, error) {
+func (m *mockTrans) waitFor(event string) (int, []byte, error) {
 	select {
 	case e := <-m.events:
 		if e.key != event {
-			return 0, fmt.Errorf("got %s, expected %s", e.key, event)
+			return 0, nil, fmt.Errorf("got %s, expected %s", e.key, event)
 		}
-		return e.hits, nil
+		return e.hits, e.body, nil
 	case <-time.Tick(10 * time.Second):
-		return 0, fmt.Errorf("event timeout")
+		return 0, nil, fmt.Errorf("event timeout")
 	}
 }
 
-func (m *mockTrans) newServiceRecord() (b []byte, err error) {
+func newServiceRecord() []byte {
 	f := forms.ServiceRecord_v1{
 		Id:            13, // NOTE: this should match with eventUnregister
 		Created:       time.Now().Format(time.RFC3339),
 		EndOfValidity: time.Now().Format(time.RFC3339),
 		Version:       "ServiceRecord_v1",
 	}
-	return usecases.Pack(&f, "application/json")
+	b, err := usecases.Pack(&f, "application/json")
+	if err != nil {
+		panic(err) // Hard fail if Pack() can't handle the above form
+	}
+	return b
 }
 
-func (m *mockTrans) newServicePoint() (b []byte, err error) {
+func newServicePoint() []byte {
 	f := forms.ServicePoint_v1{
 		// per usecases/registration.go:serviceRegistrationForm()
 		ServNode: fmt.Sprintf("localhost_%s_%s_%s", systemName, unitName, unitService),
 		// per orchestrator/thing.go:selectService()
 		ServLocation: fmt.Sprintf("http://localhost:%d/%s/%s/%s",
-			m.sys.Husk.ProtoPort["http"], systemName, unitName, unitService,
+			systemPort, systemName, unitName, unitService,
 		),
 		Version: "ServicePoint_v1",
 	}
-	return usecases.Pack(&f, "application/json")
+	b, err := usecases.Pack(&f, "application/json")
+	if err != nil {
+		panic(err) // Another hard fail if Pack() can't work with the above form
+	}
+	return b
 }
 
 const (
@@ -275,78 +284,63 @@ const (
 	eventOrchestrate    string = "POST /orchestrator/orchestration/squest"
 )
 
+var mockRequests = map[string]struct {
+	sendEvent bool
+	status    int
+	body      []byte
+}{
+	eventRegistryStatus: {false, 200, []byte(components.ServiceRegistrarLeader)},
+	eventRegister:       {true, 200, newServiceRecord()},
+	eventUnregister:     {true, 200, nil},
+	eventOrchestration:  {false, 200, nil},
+	eventOrchestrate:    {true, 200, newServicePoint()},
+}
+
 func (m *mockTrans) RoundTrip(req *http.Request) (*http.Response, error) {
-	resp := &http.Response{
-		StatusCode: http.StatusNotImplemented,
-		Request:    req,
-		Header: map[string][]string{
-			"Content-Type": {"application/json"},
-		},
-	}
-	body, key := "", req.Method+" "+req.URL.Path
+	m.mutex.Lock() // This lock is mainly for guarding concurrent access to the hits map
+	defer m.mutex.Unlock()
+	key := req.Method + " " + req.URL.Path
 	m.hits[key] += 1
-	switch key {
-
-	// Find leading registrar
-	case eventRegistryStatus:
-		resp.StatusCode, body = 200, components.ServiceRegistrarLeader
-
-	// Register services with registrar
-	case eventRegister:
-		// TODO: validate body
-		// b, err := io.ReadAll(req.Body)
-		// if err != nil {
-		// 	return nil, err
-		// }
-		// defer req.Body.Close()
-		// fmt.Println(string(b))
-		f, err := m.newServiceRecord()
-		if err != nil {
-			return nil, err
-		}
-		m.events <- event{key, m.hits[key]}
-		resp.StatusCode, body = 200, string(f)
-
-	// Unregister services
-	case eventUnregister:
-		m.events <- event{key, m.hits[key]}
-
-	case eventOrchestration:
-		resp.StatusCode = 200
-
-	case eventOrchestrate:
-		// TODO: validate body
-		// b, err := io.ReadAll(req.Body)
-		// if err != nil {
-		// 	return nil, err
-		// }
-		// defer req.Body.Close()
-		// fmt.Println(string(b))
-		f, err := m.newServicePoint()
-		if err != nil {
-			return nil, err
-		}
-		resp.StatusCode, body = 200, string(f)
-
-	case fmt.Sprintf("GET /%s/%s/%s", systemName, unitName, unitService):
-		var err error
-		resp, err = http.DefaultTransport.RoundTrip(req)
-		if err != nil {
-			return nil, err
-		}
+	if key == serviceURL {
+		// The example service will, through the system, return a proper response
+		return http.DefaultTransport.RoundTrip(req)
+	}
 
-	default:
+	// Any other requests needs to be mocked, simulating responses from the
+	// service registrar and orchestrator.
+	mock, found := mockRequests[key]
+	if !found {
 		m.t.Errorf("unknown request: %s", key)
+		// Let's see how the system responds to this
+		mock.status = http.StatusNotImplemented
+		mock.body = []byte(http.StatusText(mock.status))
 	}
-
-	resp.Status = http.StatusText(resp.StatusCode)
-	if len(body) > 0 {
-		resp.Body = io.NopCloser(strings.NewReader(body))
-		resp.ContentLength = int64(len(body))
+	rec := httptest.NewRecorder()
+	rec.Header().Set("Content-Type", "application/json")
+	rec.WriteHeader(mock.status)
+	rec.Write(mock.body) // Safe to ignore the returned error, it's always nil
+
+	// Allows for syncing up the test, with the request flow performed by the system
+	if mock.sendEvent {
+		var b []byte
+		if req.Body != nil {
+			var err error
+			b, err = io.ReadAll(req.Body)
+			if err != nil {
+				m.t.Errorf("failed reading request body: %v", err)
+			}
+			defer req.Body.Close()
+		}
+		// Using a goroutine prevents thread locking
+		go func(k string, h int, b []byte) {
+			m.events <- event{k, h, b}
+		}(key, m.hits[key], b)
 	}
-	return resp, nil
+	return rec.Result(), nil
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 func countGoroutines() (int, string) {
 	c := runtime.NumGoroutine()
 	buf := &bytes.Buffer{}
@@ -365,44 +359,63 @@ func countGoroutines() (int, string) {
 	return c, trace
 }
 
+func assertNotEq(t *testing.T, got, want any) {
+	if got != want {
+		t.Errorf("got %v, expected %v", got, want)
+	}
+}
+
 func TestSimpleSystemIntegration(t *testing.T) {
 	routinesStart, _ := countGoroutines()
 	m := newMockTransport(t)
-	sys, stop, err := newSystem()
+	sys, stopSystem, err := newSystem()
 	if err != nil {
 		t.Fatalf("expected no error, got: %s", err)
 	}
-	m.trackSystem(sys)
 
 	// Validate service registration
-	hits, err := m.waitFor(eventRegister)
-	if err != nil {
-		t.Fatal(err)
-	}
+	hits, body, err := m.waitFor(eventRegister)
+	assertNotEq(t, err, nil)
 	if hits != 1 {
 		t.Errorf("system skipped: %s", eventRegister)
 	}
-
-	// Validate service use
-	service := m.ua.GetCervices()[unitService]
+	var sr forms.ServiceRecord_v1
+	err = json.Unmarshal(body, &sr)
+	assertNotEq(t, err, nil)
+	assertNotEq(t, sr.SystemName, systemName)
+	assertNotEq(t, sr.SubPath, path.Join(unitName, unitService))
+
+	// Validate service usage
+	ua := *sys.UAssets[unitName]
+	if ua == nil {
+		t.Fatalf("system missing unit asset: %s", unitName)
+	}
+	service := ua.GetCervices()[unitService]
 	if service == nil {
 		t.Fatalf("unit asset missing cervice: %s", unitService)
 	}
 	f, err := usecases.GetState(service, sys)
-	if err != nil {
-		t.Errorf("error from GetState: %s", err)
-	}
+	assertNotEq(t, err, nil)
 	fs, ok := f.(*forms.SignalA_v1a)
 	if ok == false || fs == nil || fs.Value == 0.0 {
 		t.Errorf("invalid form: %#v", f)
 	}
 
-	// Validate service unregister
-	stop()
-	hits, err = m.waitFor(eventUnregister)
-	if err != nil {
-		t.Fatal(err)
+	// Late validation for service discovery
+	hits, body, err = m.waitFor(eventOrchestrate)
+	assertNotEq(t, err, nil)
+	if hits != 1 {
+		t.Errorf("system skipped: %s", eventUnregister)
 	}
+	var sq forms.ServiceQuest_v1
+	err = json.Unmarshal(body, &sq)
+	assertNotEq(t, err, nil)
+	assertNotEq(t, sq.ServiceDefinition, unitService)
+
+	// Validate service unregister
+	stopSystem()
+	hits, _, err = m.waitFor(eventUnregister) // NOTE: doesn't receive a body
+	assertNotEq(t, err, nil)
 	if hits != 1 {
 		t.Errorf("system skipped: %s", eventUnregister)
 	}

From fa6f875f33386f4cef17a6c41bcc9b97a00ef1d5 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 4 Jul 2025 10:55:47 +0200
Subject: [PATCH 115/186] Splits up test file, adds more comments and cleaning
 up small things

---
 tests/configuration.go    |  55 ++++++++++
 tests/examples_test.go    | 162 +++++++++++++++++++++++++++
 tests/integration_test.go | 225 ++++----------------------------------
 3 files changed, 236 insertions(+), 206 deletions(-)
 create mode 100644 tests/configuration.go
 create mode 100644 tests/examples_test.go

diff --git a/tests/configuration.go b/tests/configuration.go
new file mode 100644
index 0000000..2f52ea3
--- /dev/null
+++ b/tests/configuration.go
@@ -0,0 +1,55 @@
+package tests
+
+import (
+	"encoding/json"
+	"os/signal"
+
+	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/usecases"
+)
+
+// PROPOSAL: new additions to usecases/configuration.go
+
+// NewResourceFunc is the function type used for loading unit assets that were
+// defined in "systemconfig.json".
+// A new, custom instance of [Components.UnitAsset] should be created and populated
+// with fields from the provided [usecases.ConfigurableAsset].
+// Any services or consumed services should be added too.
+// The function should then return the UnitAsset and an optional cleanup function.
+//
+// TODO: this function really needs an error return
+// TODO: feels unnecessarily confusing to provide system instance.
+type NewResourceFunc func(usecases.ConfigurableAsset, *components.System) (components.UnitAsset, func())
+
+// LoadResources loads all unit assets from rawRes (which was loaded from "systemconfig.json" file)
+// and calls newResFunc repeatedly for each loaded asset.
+// The fully loaded unit asset and an optional cleanup function are collected from
+// newResFunc and are then attached to the sys system.
+// LoadResources then returns a system cleanup function and an optional error.
+// The error always originate from [json.Unmarshal].
+func LoadResources(sys *components.System, rawRes []json.RawMessage, newResFunc NewResourceFunc) (func(), error) {
+	// Resets this map so it can be filled with loaded unit assets (rather than templates)
+	sys.UAssets = make(map[string]*components.UnitAsset)
+
+	var cleanups []func()
+	for _, raw := range rawRes {
+		var ca usecases.ConfigurableAsset
+		if err := json.Unmarshal(raw, &ca); err != nil {
+			return func() {}, err
+		}
+
+		ua, f := newResFunc(ca, sys)
+		sys.UAssets[ua.GetName()] = &ua
+		cleanups = append(cleanups, f)
+	}
+
+	doCleanups := func() {
+		for _, f := range cleanups {
+			f()
+		}
+		// Stops hijacking SIGINT and return signal control to user
+		signal.Stop(sys.Sigs)
+		close(sys.Sigs)
+	}
+	return doCleanups, nil
+}
diff --git a/tests/examples_test.go b/tests/examples_test.go
new file mode 100644
index 0000000..a9c5d7a
--- /dev/null
+++ b/tests/examples_test.go
@@ -0,0 +1,162 @@
+package tests
+
+import (
+	"context"
+	"math/rand"
+	"net/http"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/forms"
+	"github.com/sdoque/mbaigo/usecases"
+)
+
+const (
+	unitName    string = "randomiser"
+	unitService string = "random"
+)
+
+// The most simplest unit asset
+type uaRandomiser struct {
+	Name        string              `json:"-"`
+	Owner       *components.System  `json:"-"`
+	Details     map[string][]string `json:"-"`
+	ServicesMap components.Services `json:"-"`
+	CervicesMap components.Cervices `json:"-"`
+}
+
+// Force type check (fulfilling the interface) at compile time
+var _ components.UnitAsset = &uaRandomiser{}
+
+// Add required functions to fulfil the UnitAsset interface
+func (ua uaRandomiser) GetName() string                  { return ua.Name }
+func (ua uaRandomiser) GetServices() components.Services { return ua.ServicesMap }
+func (ua uaRandomiser) GetCervices() components.Cervices { return ua.CervicesMap }
+func (ua uaRandomiser) GetDetails() map[string][]string  { return ua.Details }
+
+func (ua uaRandomiser) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
+	if servicePath != unitService {
+		http.Error(w, "unknown service path: "+servicePath, http.StatusBadRequest)
+		return
+	}
+
+	f := forms.SignalA_v1a{
+		Value: rand.Float64(),
+	}
+	b, err := usecases.Pack(f.NewForm(), "application/json")
+	if err != nil {
+		http.Error(w, "error from Pack: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if _, err := w.Write(b); err != nil {
+		http.Error(w, "error from Write: "+err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func createUATemplate(sys *components.System) {
+	s := &components.Service{
+		Definition: unitService, // The "name" of the service
+		SubPath:    unitService, // Not "allowed" to be changed afterwards
+		Details:    map[string][]string{"key1": {"value1"}},
+		RegPeriod:  60,
+		// NOTE: must start with lower-case, it gets embedded into another sentence in the web API
+		Description: "returns a random float64",
+	}
+	ua := components.UnitAsset(&uaRandomiser{
+		Name:    unitName, // WARN: don't use the system name!! this is an asset!
+		Details: map[string][]string{"key2": {"value2"}},
+		ServicesMap: components.Services{
+			s.SubPath: s,
+		},
+	})
+	sys.UAssets[ua.GetName()] = &ua
+}
+
+func loadUAConfig(ca usecases.ConfigurableAsset, sys *components.System) (components.UnitAsset, func()) {
+	s := ca.Services[0]
+	ua := &uaRandomiser{
+		Name:        ca.Name,
+		Owner:       sys,
+		Details:     ca.Details,
+		ServicesMap: usecases.MakeServiceMap(ca.Services),
+		// Let it consume its own service
+		CervicesMap: components.Cervices{unitService: &components.Cervice{
+			Definition: s.Definition,
+			Details:    s.Details,
+			// Nodes will be filled up by any discovered cervices
+			Nodes: make(map[string][]string, 0),
+		}},
+	}
+	return ua, func() {}
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+const (
+	systemName string = "test"
+	systemPort int    = 29999
+)
+
+var serviceURL = "GET /" + path.Join(systemName, unitName, unitService)
+
+// The most simplest system
+func newSystem() (*components.System, func(), error) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// TODO: want this to return a pointer type instead!
+	// easier to use and pointer is used all the time anyway down below
+	sys := components.NewSystem(systemName, ctx)
+	sys.Husk = &components.Husk{
+		Description: " is the most simplest system possible",
+		Details:     map[string][]string{"key3": {"value3"}},
+		ProtoPort:   map[string]int{"http": systemPort},
+	}
+
+	// Setup default config with default unit asset and values
+	createUATemplate(&sys)
+	rawResources, err := usecases.Configure(&sys)
+
+	// Extra check to work around "created config" error. Not required normally!
+	if err != nil {
+		// TODO: once configuration PR is merged, check for ErrCreatedConfig blah instead
+		if !strings.Contains(err.Error(), "a new configuration file") {
+			cancel()
+			return nil, nil, err
+		}
+		// Since Configure() created the config file, it must be cleaned up when this test is done!
+		defer os.Remove("systemconfig.json")
+		// Default config file was created, redo the func call to load the file
+		rawResources, err = usecases.Configure(&sys)
+		if err != nil {
+			cancel()
+			return nil, nil, err
+		}
+	}
+	// NOTE: if the config file already existed (thus the above error block didn't
+	// get to run), then the config file should be left alone and not removed!
+
+	// Load unit assets defined in the config file
+	cleanups, err := LoadResources(&sys, rawResources, loadUAConfig)
+	if err != nil {
+		cancel()
+		return nil, nil, err
+	}
+
+	// TODO: this is not ready for production yet?
+	// usecases.RequestCertificate(&sys)
+
+	usecases.RegisterServices(&sys)
+
+	// TODO: prints logs
+	usecases.SetoutServers(&sys)
+
+	stop := func() {
+		cancel()
+		// TODO: a waitgroup or something should be used to make sure all goroutines have stopped
+		// Not doing much in the mock cleanups so this works fine for now...?
+		cleanups()
+	}
+	return &sys, stop, nil
+}
diff --git a/tests/integration_test.go b/tests/integration_test.go
index fa862f7..3ccf208 100644
--- a/tests/integration_test.go
+++ b/tests/integration_test.go
@@ -2,15 +2,11 @@ package tests
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
-	"math/rand/v2"
 	"net/http"
 	"net/http/httptest"
-	"os"
-	"os/signal"
 	"path"
 	"runtime"
 	"runtime/pprof"
@@ -24,209 +20,25 @@ import (
 	"github.com/sdoque/mbaigo/usecases"
 )
 
-////////////////////////////////////////////////////////////////////////////////
-// The most simplest unit asset
-
-const (
-	unitName    string = "randomiser"
-	unitService string = "random"
-)
-
-// Force type check (fulfilling the interface) at compile time
-var _ components.UnitAsset = &uaRandomiser{}
-
-type uaRandomiser struct {
-	Name        string              `json:"-"`
-	Owner       *components.System  `json:"-"`
-	Details     map[string][]string `json:"-"`
-	ServicesMap components.Services `json:"-"`
-	CervicesMap components.Cervices `json:"-"`
-}
-
-// Add required functions to fulfil the UnitAsset interface
-func (ua uaRandomiser) GetName() string                  { return ua.Name }
-func (ua uaRandomiser) GetServices() components.Services { return ua.ServicesMap }
-func (ua uaRandomiser) GetCervices() components.Cervices { return ua.CervicesMap }
-func (ua uaRandomiser) GetDetails() map[string][]string  { return ua.Details }
-func (ua uaRandomiser) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
-	if servicePath != unitService {
-		http.Error(w, "unknown service path: "+servicePath, http.StatusBadRequest)
-		return
-	}
-	f := forms.SignalA_v1a{
-		Value: rand.Float64(),
-	}
-	b, err := usecases.Pack(f.NewForm(), "application/json")
-	if err != nil {
-		http.Error(w, "error from Pack: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-	if _, err := w.Write(b); err != nil {
-		http.Error(w, "error from Write: "+err.Error(), http.StatusInternalServerError)
-	}
-}
-
-func addUATemplate(sys *components.System) {
-	s := &components.Service{
-		Definition: unitService, // The "name" of the service
-		SubPath:    unitService, // Not "allowed" to be changed afterwards
-		Details:    map[string][]string{"key1": {"value1"}},
-		RegPeriod:  60,
-		// NOTE: must start with lower-case, it gets embedded into another sentence in the web API
-		Description: "returns a random float64",
-	}
-	ua := components.UnitAsset(&uaRandomiser{
-		Name:    unitName, // WARN: don't use the system name!! this is an asset!
-		Details: map[string][]string{"key2": {"value2"}},
-		ServicesMap: components.Services{
-			s.SubPath: s,
-		},
-	})
-	sys.UAssets[ua.GetName()] = &ua
-}
-
-func loadUA(ca usecases.ConfigurableAsset, sys *components.System) (components.UnitAsset, func()) {
-	s := ca.Services[0]
-	ua := &uaRandomiser{
-		Name:        ca.Name,
-		Owner:       sys,
-		Details:     ca.Details,
-		ServicesMap: usecases.MakeServiceMap(ca.Services),
-		// Let it consume its own service
-		CervicesMap: components.Cervices{unitService: &components.Cervice{
-			Definition: s.Definition,
-			Details:    s.Details,
-			// Nodes will be filled up by any discovered cervices
-			Nodes: make(map[string][]string, 0),
-		}},
-	}
-	return ua, func() {}
+type requestEvent struct {
+	event string
+	hits  int
+	body  []byte
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// The most simplest system
-
-const (
-	systemName string = "test"
-	systemPort int    = 29999
-)
-
-var serviceURL = "GET /" + path.Join(systemName, unitName, unitService)
-
-func newSystem() (*components.System, func(), error) {
-	ctx, cancel := context.WithCancel(context.Background())
-
-	// TODO: want this to return a pointer type instead!
-	// easier to use and pointer is used all the time anyway down below
-	sys := components.NewSystem(systemName, ctx)
-	sys.Husk = &components.Husk{
-		Description: " is the most simplest system possible",
-		Details:     map[string][]string{"key3": {"value3"}},
-		ProtoPort:   map[string]int{"http": systemPort},
-	}
-
-	// Setup default config with default unit asset and values
-	addUATemplate(&sys)
-	rawResources, err := usecases.Configure(&sys)
-
-	// Extra check to work around "created config" error. Not required normally!
-	if err != nil {
-		// TODO: once configuration PR is merged, check for ErrCreatedConfig blah instead
-		if !strings.Contains(err.Error(), "a new configuration file") {
-			cancel()
-			return nil, nil, err
-		}
-		// Since Configure() created the config file, it must be cleaned up when this test is done!
-		defer os.Remove("systemconfig.json")
-		// Default config file was created, redo the func call to load the file
-		rawResources, err = usecases.Configure(&sys)
-		if err != nil {
-			cancel()
-			return nil, nil, err
-		}
-	}
-	// NOTE: if the config file already existed (thus the above error block didn't
-	// get to run), then the config file should be left alone and not removed!
-
-	// Load unit assets defined in the config file
-	cleanups, err := LoadResources(&sys, rawResources, loadUA)
-	if err != nil {
-		cancel()
-		return nil, nil, err
-	}
-
-	// TODO: this is not ready for production yet?
-	// usecases.RequestCertificate(&sys)
-
-	// TODO: prints logs?
-	usecases.RegisterServices(&sys)
-
-	// TODO: prints logs??
-	usecases.SetoutServers(&sys)
-
-	stop := func() {
-		cancel()
-		// TODO: a waitgroup or something should be used to make sure all goroutines have stopped
-		// Not doing much in the mock cleanups so this works fine for now...?
-		cleanups()
-	}
-	return &sys, stop, nil
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// PROPOSAL: new additions to usecases/configuration.go?
-
-// TODO: this function really needs an error return too
-type NewResourceFunc func(usecases.ConfigurableAsset, *components.System) (components.UnitAsset, func())
-
-func LoadResources(sys *components.System, rawRes []json.RawMessage, newRes NewResourceFunc) (func(), error) {
-	// Resets this map so it can be filled with loaded unit assets (rather than templates)
-	sys.UAssets = make(map[string]*components.UnitAsset)
-
-	var cleanups []func()
-	for _, raw := range rawRes {
-		var ca usecases.ConfigurableAsset
-		if err := json.Unmarshal(raw, &ca); err != nil {
-			return func() {}, err
-		}
-
-		ua, f := newRes(ca, sys)
-		sys.UAssets[ua.GetName()] = &ua
-		cleanups = append(cleanups, f)
-	}
-
-	doCleanups := func() {
-		for _, f := range cleanups {
-			f()
-		}
-		// Stops hijacking SIGINT and return signal control to user
-		signal.Stop(sys.Sigs)
-		close(sys.Sigs)
-	}
-	return doCleanups, nil
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // Mock simulating traffic between a system and registrars/orchestrators
-
-type event struct {
-	key  string
-	hits int
-	body []byte
-}
-
 type mockTrans struct {
 	t      *testing.T
-	hits   map[string]int // Used to track http requests
-	mutex  sync.Mutex     // For protecting access to the above map
-	events chan event
+	hits   map[string]int    // Used to track http requests
+	mutex  sync.Mutex        // For protecting access to the above map
+	events chan requestEvent // Tracks service "events" and requests to the cloud services
 }
 
 func newMockTransport(t *testing.T) *mockTrans {
 	m := &mockTrans{
 		t:      t,
 		hits:   make(map[string]int),
-		events: make(chan event),
+		events: make(chan requestEvent),
 	}
 	// Hijack the default http client so no actual http requests are sent over the network
 	http.DefaultClient.Transport = m
@@ -236,8 +48,8 @@ func newMockTransport(t *testing.T) *mockTrans {
 func (m *mockTrans) waitFor(event string) (int, []byte, error) {
 	select {
 	case e := <-m.events:
-		if e.key != event {
-			return 0, nil, fmt.Errorf("got %s, expected %s", e.key, event)
+		if e.event != event {
+			return 0, nil, fmt.Errorf("got %s, expected %s", e.event, event)
 		}
 		return e.hits, e.body, nil
 	case <-time.Tick(10 * time.Second):
@@ -299,18 +111,18 @@ var mockRequests = map[string]struct {
 func (m *mockTrans) RoundTrip(req *http.Request) (*http.Response, error) {
 	m.mutex.Lock() // This lock is mainly for guarding concurrent access to the hits map
 	defer m.mutex.Unlock()
-	key := req.Method + " " + req.URL.Path
-	m.hits[key] += 1
-	if key == serviceURL {
+	event := req.Method + " " + req.URL.Path
+	m.hits[event] += 1
+	if event == serviceURL {
 		// The example service will, through the system, return a proper response
 		return http.DefaultTransport.RoundTrip(req)
 	}
 
 	// Any other requests needs to be mocked, simulating responses from the
 	// service registrar and orchestrator.
-	mock, found := mockRequests[key]
+	mock, found := mockRequests[event]
 	if !found {
-		m.t.Errorf("unknown request: %s", key)
+		m.t.Errorf("unknown request: %s", event)
 		// Let's see how the system responds to this
 		mock.status = http.StatusNotImplemented
 		mock.body = []byte(http.StatusText(mock.status))
@@ -332,9 +144,9 @@ func (m *mockTrans) RoundTrip(req *http.Request) (*http.Response, error) {
 			defer req.Body.Close()
 		}
 		// Using a goroutine prevents thread locking
-		go func(k string, h int, b []byte) {
-			m.events <- event{k, h, b}
-		}(key, m.hits[key], b)
+		go func(e string, h int, b []byte) {
+			m.events <- requestEvent{e, h, b}
+		}(event, m.hits[event], b)
 	}
 	return rec.Result(), nil
 }
@@ -423,6 +235,7 @@ func TestSimpleSystemIntegration(t *testing.T) {
 	// Detect any leaking goroutines
 	// Delay a short moment and let the goroutines finish. Not sure if there's
 	// a better way to wait for an _unknown number_ of goroutines.
+	// This might give flaky test results in slower environments!
 	time.Sleep(1 * time.Second)
 	routinesStop, trace := countGoroutines()
 	if (routinesStop - routinesStart) != 0 {

From cddc78b4395aa68f162af8732486fc1f646c4827 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 4 Jul 2025 11:25:18 +0200
Subject: [PATCH 116/186] Checks for ErrNewConfig during integration test

---
 tests/examples_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/examples_test.go b/tests/examples_test.go
index a9c5d7a..b22656c 100644
--- a/tests/examples_test.go
+++ b/tests/examples_test.go
@@ -2,11 +2,11 @@ package tests
 
 import (
 	"context"
+	"errors"
 	"math/rand"
 	"net/http"
 	"os"
 	"path"
-	"strings"
 
 	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
@@ -120,8 +120,8 @@ func newSystem() (*components.System, func(), error) {
 
 	// Extra check to work around "created config" error. Not required normally!
 	if err != nil {
-		// TODO: once configuration PR is merged, check for ErrCreatedConfig blah instead
-		if !strings.Contains(err.Error(), "a new configuration file") {
+		// Return errors not related to config creation
+		if errors.Is(err, usecases.ErrNewConfig) == false {
 			cancel()
 			return nil, nil, err
 		}

From 02cb4a98203cac1be94cb2755bf9a83c94e47837 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sat, 5 Jul 2025 11:10:17 +0200
Subject: [PATCH 117/186] Replaces the last fmt.Print with log

But kept a couple of prints in the in progress code.
---
 components/system.go  | 2 ++
 usecases/kgraphing.go | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/components/system.go b/components/system.go
index 4ee937f..6251ca4 100644
--- a/components/system.go
+++ b/components/system.go
@@ -137,6 +137,8 @@ var (
 )
 
 func getBuildInfo() {
+	// TODO: This info should be updated when setting up version release tools
+	// Leaving the fmt.Prints as is for now.
 	if AppName != "" {
 		fmt.Printf("System: %s - %s\n", AppName, Version)
 		fmt.Printf("Build date: %s\n", BuildDate)
diff --git a/usecases/kgraphing.go b/usecases/kgraphing.go
index f7ca517..a914674 100644
--- a/usecases/kgraphing.go
+++ b/usecases/kgraphing.go
@@ -48,7 +48,7 @@ func KGraphing(w http.ResponseWriter, req *http.Request, sys *components.System)
 	w.Header().Set("Content-Type", "text/turtle")
 	_, err := w.Write([]byte(rdf))
 	if err != nil {
-		fmt.Println("Failed to write KGraphing information: ", err)
+		log.Println("Failed to write KGraphing information: ", err)
 	}
 }
 

From 4749f51dc1b9c6470f77716b9e35261dde79a0b7 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sat, 5 Jul 2025 16:24:48 +0200
Subject: [PATCH 118/186] Cleans up error handling in components/host and
 usecases/provision

---
 components/host.go    |  1 -
 usecases/provision.go | 25 ++++++++++++++-----------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/components/host.go b/components/host.go
index dc389c5..6657404 100644
--- a/components/host.go
+++ b/components/host.go
@@ -67,7 +67,6 @@ func NewDevice() *HostingDevice {
 func Hostname() (string, error) {
 	name, err := os.Hostname()
 	if err != nil {
-		log.Println(err.Error())
 		return "", err
 	}
 	return name, nil
diff --git a/usecases/provision.go b/usecases/provision.go
index 7188dd0..12ee15a 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -30,6 +30,8 @@ import (
 )
 
 // HTTPProcessSetRequest processes a Get request
+// TODO: this function should really return an error too and behave like everyone
+// else. And causing http.Errors is an ugly side effect.
 func HTTPProcessGetRequest(w http.ResponseWriter, r *http.Request, f forms.Form) {
 	if f == nil {
 		http.Error(w, "No payload found.", http.StatusNotFound)
@@ -60,23 +62,25 @@ func HTTPProcessGetRequest(w http.ResponseWriter, r *http.Request, f forms.Form)
 }
 
 // HTTPProcessSetRequest processes a SET request
-func HTTPProcessSetRequest(w http.ResponseWriter, req *http.Request) (forms.SignalA_v1a, error) {
-	defer req.Body.Close()
+func HTTPProcessSetRequest(w http.ResponseWriter, req *http.Request) (sig forms.SignalA_v1a, err error) {
 	bodyBytes, err := io.ReadAll(req.Body) // Use io.ReadAll instead of ioutil.ReadAll
 	if err != nil {
-		log.Printf("Error reading request body: %v", err)
-		return forms.SignalA_v1a{}, err
+		err = fmt.Errorf("reading request body: %w", err)
+		return
 	}
+	defer req.Body.Close()
 	headerContentType := req.Header.Get("Content-Type")
-	form, err := Unpack(bodyBytes, headerContentType)
+	f, err := Unpack(bodyBytes, headerContentType)
 	if err != nil {
-		return forms.SignalA_v1a{}, err
+		return
 	}
-	f, ok := form.(*forms.SignalA_v1a)
+	temp, ok := f.(*forms.SignalA_v1a)
 	if !ok {
-		return forms.SignalA_v1a{}, fmt.Errorf("form is not of type SignalA_v1a")
+		err = fmt.Errorf("form is not of type SignalA_v1a")
+		return
 	}
-	return *f, nil
+	sig = *temp // Stupid type conversion because return type was picked incorrectly
+	return
 }
 
 // getBestContentType parses the Accept header and returns the best content type based on q-values
@@ -99,8 +103,7 @@ func getBestContentType(acceptHeader string) string {
 		if len(parts) > 1 && strings.HasPrefix(parts[1], "q=") {
 			_, err := fmt.Sscanf(parts[1], "q=%f", &qValue)
 			if err != nil {
-				// TODO: More might need to happen here?
-				log.Printf("Error while scanning parts of mimeType: %v", err)
+				continue
 			}
 		}
 

From cc890b26b39d5b65b903aa7b11b9514c6bf335dd Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sat, 5 Jul 2025 16:24:48 +0200
Subject: [PATCH 119/186] Cleans up error handling in
 usecases/service_discovery

---
 usecases/service_discovery.go      | 25 ++++++++++---------------
 usecases/service_discovery_test.go |  4 ++--
 2 files changed, 12 insertions(+), 17 deletions(-)

diff --git a/usecases/service_discovery.go b/usecases/service_discovery.go
index 3240ab9..701f579 100644
--- a/usecases/service_discovery.go
+++ b/usecases/service_discovery.go
@@ -24,7 +24,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"net/http"
 
 	"github.com/sdoque/mbaigo/components"
@@ -52,12 +51,12 @@ func ExtractQuestForm(bodyBytes []byte) (rec forms.ServiceQuest_v1, err error) {
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		log.Printf("Error unmarshalling JSON data: %v", err)
+		err = fmt.Errorf("unmarshalling JSON data: %v", err)
 		return
 	}
 	formVersion, ok := jsonData["version"].(string)
 	if !ok {
-		log.Printf("'version' key not found in JSON data")
+		err = fmt.Errorf("'version' key not found in JSON data")
 		return
 	}
 
@@ -66,7 +65,7 @@ func ExtractQuestForm(bodyBytes []byte) (rec forms.ServiceQuest_v1, err error) {
 		var f forms.ServiceQuest_v1
 		err = json.Unmarshal(bodyBytes, &f)
 		if err != nil {
-			log.Println("Unable to extract the discovery form request ")
+			err = fmt.Errorf("unable to extract the discovery form request ")
 			return
 		}
 		rec = f
@@ -97,29 +96,25 @@ func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocat
 	// Create a new HTTP request to the Orchestrator system (for now the Service Registrar)
 	orURL, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
 	if err != nil {
-		return servLocation, err
+		return
 	}
 	// prepare the payload to perform a service quest
 	orURL = orURL + "/squest"
 	jsonQF, err := json.MarshalIndent(qf, "", "  ")
 	if err != nil {
-		return servLocation, err
+		return
 	}
 	resp, err := sendHttpReq(http.MethodPost, orURL, jsonQF)
 	if err != nil {
-		return servLocation, err
+		return
 	}
 	defer resp.Body.Close()
 	// Read the response /////////////////////////////////
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return servLocation, err
-	}
-	servLocation, err = ExtractDiscoveryForm(body)
-	if err != nil {
-		return servLocation, err
+		return
 	}
-	return servLocation, err
+	return ExtractDiscoveryForm(body)
 }
 
 // Search4Services requests from the core systems the address of resources' services that meet the need
@@ -194,7 +189,7 @@ func ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err err
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		log.Printf("Error unmarshalling JSON data: %v", err)
+		err = fmt.Errorf("unmarshalling JSON data: %v", err)
 		return
 	}
 	formVersion, ok := jsonData["version"].(string)
@@ -208,7 +203,7 @@ func ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err err
 		f.NewForm()
 		err = json.Unmarshal(bodyBytes, &f)
 		if err != nil {
-			log.Println("Unable to extract registration request ")
+			err = fmt.Errorf("unmarshalling JSON data: %v", err)
 			return
 		}
 		sLoc = f
diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index 47dd932..332f28c 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -117,9 +117,9 @@ func TestExtractQuestForm(t *testing.T) {
 		}
 		// Do the test
 		rec, err := ExtractQuestForm(data)
-		if x.testCase == "No errors" || x.testCase == "Missing version" {
+		if x.testCase == "No errors" {
 			if err != nil {
-				t.Errorf("Test case: '%s' got error: %e", x.testCase, err)
+				t.Errorf("Test case: '%s' got error: %v", x.testCase, err)
 			}
 			if x.testCase == "Missing version" && rec.Version != "" {
 				t.Errorf("---\tExpected no version, got %s", rec.Version)

From fdf32c88de990417f2522b9483c6ccbe1fb3af2d Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Fri, 4 Jul 2025 13:43:08 +0200
Subject: [PATCH 120/186] First version of test for forms/file_forms.go

---
 forms/forms_test.go | 153 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 forms/forms_test.go

diff --git a/forms/forms_test.go b/forms/forms_test.go
new file mode 100644
index 0000000..12d6697
--- /dev/null
+++ b/forms/forms_test.go
@@ -0,0 +1,153 @@
+package forms
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+type transferFileTestStruct struct {
+	inputW       http.ResponseWriter
+	filename     string
+	expectedBody string
+	expectedCode int
+	fileType     string
+	testName     string
+}
+
+type mockResponseWriter struct {
+	http.ResponseWriter
+}
+
+func (e *mockResponseWriter) Write(b []byte) (int, error) {
+	return 0, fmt.Errorf("Forced write error")
+}
+
+func (e *mockResponseWriter) WriteHeader(statusCode int) {}
+
+func (e *mockResponseWriter) Header() http.Header {
+	return make(http.Header)
+}
+
+var transferFileTestParams = []transferFileTestStruct{
+	{httptest.NewRecorder(), "test.jpeg", "\xff\xd8", 200, ".jpeg", "Good case, jpeg works"},
+	{httptest.NewRecorder(), "test.zip", "\x50\x4b\x03\x04", 200, ".zip", "Good case, zip works"},
+	{httptest.NewRecorder(), "test.txt", "\n", 200, ".txt", "Good case, txt works"},
+	{httptest.NewRecorder(), "test.owl", `<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"` +
+		`xmlns:owl="http://www.w3.org/2002/07/owl#"><owl:Ontology rdf:about=""/></rdf:RDF>`, 200, ".owl", "Good case, owl works"},
+	{httptest.NewRecorder(), "test.ttl", "@prefix : <#> .@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .", 200,
+		".ttl", "Good case, ttl works"},
+	{httptest.NewRecorder(), "test.html", "<!DOCTYPE html><html><head><title></title></head><body></body></html>",
+		200, ".html", "Good case, html works"},
+	{httptest.NewRecorder(), "test.csv", "id,name\n", 200, ".csv", "Good case, csv works"},
+	{httptest.NewRecorder(), "test.mp4", "\x00\x00\x00\x18\x66\x74\x79\x70\x69\x73\x6f\x6d\x00\x00\x02\x00\x69\x73\x6f\x6d\x69\x73\x6f\x32",
+		200, ".mp4", "Good case, mp4 works"},
+	{httptest.NewRecorder(), "test.txt", "Internal Server Error\n", 500, ".txt", "Bad case, parsing url fails"},
+	{httptest.NewRecorder(), "wrong.txt", "Not Found\n", 404, ".txt", "Bad case, file not found"},
+	{&mockResponseWriter{}, "test.txt", "Failed to serve requested file\n", 500, ".txt", "Bad case, copy fails"},
+}
+
+var dir = "./files"
+
+var minimalJPEG = []byte{0xFF, 0xD8}
+var minimalZIP = []byte{0x50, 0x4B, 0x03, 0x04}
+var minimalTXT = []byte("\n")
+var minimalOWL = []byte(`<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"` +
+	`xmlns:owl="http://www.w3.org/2002/07/owl#"><owl:Ontology rdf:about=""/></rdf:RDF>`)
+var minimalTTL = []byte("@prefix : <#> .@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .")
+var minimalHTML = []byte("<!DOCTYPE html><html><head><title></title></head><body></body></html>")
+var minimalCSV = []byte("id,name\n")
+var minimalMP4 = []byte{0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6F, 0x6D,
+	0x00, 0x00, 0x02, 0x00, 0x69, 0x73, 0x6F, 0x6D, 0x69, 0x73, 0x6F, 0x32}
+
+func createTestFolderAndFile(filename string, fileType string) {
+	fullPath := "./" + filepath.Join(dir, filename)
+	err := os.MkdirAll(dir, 0755)
+	if err != nil {
+		log.Fatalf("Error creating test directory: %v", err)
+		return
+	}
+
+	f, err := os.OpenFile(fullPath, os.O_CREATE|os.O_RDWR, 0600)
+	if err != nil {
+		if os.IsExist(err) {
+			log.Fatalf("File already exists: %v", err)
+		} else {
+			log.Fatalf("Error creating file: %v", err)
+		}
+		return
+	}
+	defer f.Close()
+
+	data := []byte{}
+	switch fileType {
+	case ".jpg", ".jpeg":
+		data = minimalJPEG
+	case ".zip":
+		data = minimalZIP
+	case ".txt":
+		data = minimalTXT
+	case ".owl":
+		data = minimalOWL
+	case ".ttl":
+		data = minimalTTL
+	case ".html", ".htm":
+		data = minimalHTML
+	case ".csv":
+		data = minimalCSV
+	case ".mp4":
+		data = minimalMP4
+	default:
+		log.Fatalf("Filetype is wrong")
+		return
+	}
+
+	err = os.WriteFile(fullPath, data, 0644)
+	if err != nil {
+		log.Fatalf("Error encoding to jpeg: %v", err)
+	}
+}
+
+func removeTestFolderAndFile(filename string) {
+	fullPath := "./" + filepath.Join(dir, filename)
+	if err := os.Remove(fullPath); err != nil {
+		log.Fatalf("Error deleting file: %v", err)
+	}
+	if err := os.Remove(dir); err != nil {
+		log.Fatalf("Error deleting directory: %v", err)
+	}
+}
+
+func TestTransferFile(t *testing.T) {
+	for _, testCase := range transferFileTestParams {
+		fullPath := "/" + filepath.Join(dir, testCase.filename)
+		inputR := httptest.NewRequest(http.MethodPost, fullPath, nil)
+		if testCase.testName == "Bad case, parsing url fails" {
+			inputR.URL.Path = "/foo%ZZbar"
+		}
+		if testCase.testName == "Bad case, file not found" {
+			inputR.URL.Path = "/files/doesNotExist.error"
+		}
+
+		createTestFolderAndFile(testCase.filename, testCase.fileType)
+		TransferFile(testCase.inputW, inputR)
+		removeTestFolderAndFile(testCase.filename)
+
+		if testCase.testName == "Bad case, copy fails" {
+			if _, ok := testCase.inputW.(*mockResponseWriter); !ok {
+				t.Errorf("Expected inputW to be of type *mockResponseWriter")
+			}
+		}
+
+		recorder, ok := testCase.inputW.(*httptest.ResponseRecorder)
+		if ok {
+			if recorder.Body.String() != testCase.expectedBody || recorder.Code != testCase.expectedCode {
+				t.Errorf("Expected: %s and %d, got: %s and %d", testCase.expectedBody, testCase.expectedCode, recorder.Body.String(), recorder.Code)
+			}
+		}
+	}
+}

From 8db504413f966beecb8ce75e2d37497129bc64f7 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Fri, 4 Jul 2025 13:48:56 +0200
Subject: [PATCH 121/186] Fixed lint error

---
 forms/forms_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/forms/forms_test.go b/forms/forms_test.go
index 12d6697..63423cc 100644
--- a/forms/forms_test.go
+++ b/forms/forms_test.go
@@ -83,7 +83,7 @@ func createTestFolderAndFile(filename string, fileType string) {
 	}
 	defer f.Close()
 
-	data := []byte{}
+	var data []byte
 	switch fileType {
 	case ".jpg", ".jpeg":
 		data = minimalJPEG

From ae0eb3d7fbdb60dedd650cbde87f5829488a4616 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Fri, 4 Jul 2025 15:32:56 +0200
Subject: [PATCH 122/186] Fixed PR comments

---
 forms/file_forms.go      |   4 +-
 forms/file_forms_test.go | 129 +++++++++++++++++++++++++++++++++
 forms/forms_test.go      | 153 ---------------------------------------
 3 files changed, 132 insertions(+), 154 deletions(-)
 create mode 100644 forms/file_forms_test.go
 delete mode 100644 forms/forms_test.go

diff --git a/forms/file_forms.go b/forms/file_forms.go
index 207ac1b..a6a4d53 100644
--- a/forms/file_forms.go
+++ b/forms/file_forms.go
@@ -57,6 +57,8 @@ func init() {
 	FormTypeMap["FileForm_v1"] = reflect.TypeOf(FileForm_v1{})
 }
 
+const dirString string = "./files"
+
 // TransferFile enables the transfer of different types files when the filename is given in the URL
 func TransferFile(w http.ResponseWriter, r *http.Request) {
 	// Parse the URL to ensure it's valid and to easily extract parts of it
@@ -94,7 +96,7 @@ func TransferFile(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Open the requested file from the ./files directory
-	dir := http.Dir("./files")
+	dir := http.Dir(dirString)
 	reqFile, err := dir.Open(filename)
 	if err != nil {
 		log.Println("Requested file not found:", err)
diff --git a/forms/file_forms_test.go b/forms/file_forms_test.go
new file mode 100644
index 0000000..c5e0469
--- /dev/null
+++ b/forms/file_forms_test.go
@@ -0,0 +1,129 @@
+package forms
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path"
+	"path/filepath"
+	"testing"
+)
+
+type transferFileTestStruct struct {
+	filename     string
+	expectedBody string
+	expectedCode int
+	fileType     string
+	testName     string
+}
+
+type mockResponseWriter struct {
+	http.ResponseWriter
+	statusCode int
+}
+
+func (e *mockResponseWriter) Write(b []byte) (int, error) {
+	e.WriteHeader(300)
+	return 0, fmt.Errorf("Forced write error")
+}
+
+func (e *mockResponseWriter) WriteHeader(statusCode int) {
+	e.statusCode = statusCode
+}
+
+func (e *mockResponseWriter) Header() http.Header {
+	return make(http.Header)
+}
+
+var transferFileTestParams = []transferFileTestStruct{
+	{"test.jpeg", "\xff\xd8", 200, ".jpeg", "Good case, jpeg works"},
+	{"test.zip", "\x50\x4b\x03\x04", 200, ".zip", "Good case, zip works"},
+	{"test.txt", "\n", 200, ".txt", "Good case, txt works"},
+	{"test.owl", `<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"` +
+		`xmlns:owl="http://www.w3.org/2002/07/owl#"><owl:Ontology rdf:about=""/></rdf:RDF>`, 200, ".owl", "Good case, owl works"},
+	{"test.ttl", "@prefix : <#> .@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .", 200,
+		".ttl", "Good case, ttl works"},
+	{"test.html", "<!DOCTYPE html><html><head><title></title></head><body></body></html>",
+		200, ".html", "Good case, html works"},
+	{"test.csv", "id,name\n", 200, ".csv", "Good case, csv works"},
+	{"test.mp4", "\x00\x00\x00\x18\x66\x74\x79\x70\x69\x73\x6f\x6d\x00\x00\x02\x00\x69\x73\x6f\x6d\x69\x73\x6f\x32",
+		200, ".mp4", "Good case, mp4 works"},
+	{"test.txt", "Internal Server Error\n", 500, ".txt", "Bad case, parsing url fails"},
+	{"wrong.txt", "Not Found\n", 404, ".txt", "Bad case, file not found"},
+}
+
+var fileTypeMap = map[string][]byte{
+	".jpeg": {0xFF, 0xD8},
+	".zip":  {0x50, 0x4B, 0x03, 0x04},
+	".txt":  []byte("\n"),
+	".owl": []byte(`<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"` +
+		`xmlns:owl="http://www.w3.org/2002/07/owl#"><owl:Ontology rdf:about=""/></rdf:RDF>`),
+	".ttl":  []byte("@prefix : <#> .@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> ."),
+	".html": []byte("<!DOCTYPE html><html><head><title></title></head><body></body></html>"),
+	".csv":  []byte("id,name\n"),
+	".mp4": {0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6F, 0x6D,
+		0x00, 0x00, 0x02, 0x00, 0x69, 0x73, 0x6F, 0x6D, 0x69, 0x73, 0x6F, 0x32},
+}
+
+func createTestFolderAndFile(filename string, fileType string) {
+	fullPath := filepath.Join(dirString, filename)
+	err := os.MkdirAll(dirString, 0755)
+	if err != nil {
+		log.Fatalf("Error creating test directory: %v", err)
+		return
+	}
+
+	f, err := os.OpenFile(fullPath, os.O_CREATE|os.O_RDWR, 0600)
+	if err != nil {
+		log.Fatalf("Error creating file: %v", err)
+		return
+	}
+	defer f.Close()
+
+	err = os.WriteFile(fullPath, fileTypeMap[fileType], 0644)
+	if err != nil {
+		log.Fatalf("Error encoding to jpeg: %v", err)
+	}
+}
+
+func removeTestFolderAndFile() {
+	if err := os.RemoveAll(dirString); err != nil {
+		log.Fatalf("Error deleting directory: %v", err)
+	}
+}
+
+func TestTransferFile(t *testing.T) {
+	for _, testCase := range transferFileTestParams {
+		fullPath := "/" + path.Join(dirString, testCase.filename)
+		inputW := httptest.NewRecorder()
+		inputR := httptest.NewRequest(http.MethodPost, fullPath, nil)
+		if testCase.testName == "Bad case, parsing url fails" {
+			inputR.URL.Path = "/foo%ZZbar"
+		}
+		if testCase.testName == "Bad case, file not found" {
+			inputR.URL.Path = "/files/doesNotExist.error"
+		}
+
+		createTestFolderAndFile(testCase.filename, testCase.fileType)
+		TransferFile(inputW, inputR)
+		removeTestFolderAndFile()
+
+		if inputW.Body.String() != testCase.expectedBody || inputW.Code != testCase.expectedCode {
+			t.Errorf("Expected: %s and %d, got: %s and %d", testCase.expectedBody, testCase.expectedCode, inputW.Body.String(), inputW.Code)
+		}
+	}
+
+	// Special case
+	fullPath := "/files/test.txt"
+	specialRecorder := &mockResponseWriter{}
+	inputR := httptest.NewRequest(http.MethodPost, fullPath, nil)
+	createTestFolderAndFile("test.txt", ".txt")
+	TransferFile(specialRecorder, inputR)
+	removeTestFolderAndFile()
+
+	if specialRecorder.statusCode != 300 {
+		t.Errorf("Expected status code 300, got: %d", specialRecorder.statusCode)
+	}
+}
diff --git a/forms/forms_test.go b/forms/forms_test.go
deleted file mode 100644
index 63423cc..0000000
--- a/forms/forms_test.go
+++ /dev/null
@@ -1,153 +0,0 @@
-package forms
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-type transferFileTestStruct struct {
-	inputW       http.ResponseWriter
-	filename     string
-	expectedBody string
-	expectedCode int
-	fileType     string
-	testName     string
-}
-
-type mockResponseWriter struct {
-	http.ResponseWriter
-}
-
-func (e *mockResponseWriter) Write(b []byte) (int, error) {
-	return 0, fmt.Errorf("Forced write error")
-}
-
-func (e *mockResponseWriter) WriteHeader(statusCode int) {}
-
-func (e *mockResponseWriter) Header() http.Header {
-	return make(http.Header)
-}
-
-var transferFileTestParams = []transferFileTestStruct{
-	{httptest.NewRecorder(), "test.jpeg", "\xff\xd8", 200, ".jpeg", "Good case, jpeg works"},
-	{httptest.NewRecorder(), "test.zip", "\x50\x4b\x03\x04", 200, ".zip", "Good case, zip works"},
-	{httptest.NewRecorder(), "test.txt", "\n", 200, ".txt", "Good case, txt works"},
-	{httptest.NewRecorder(), "test.owl", `<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"` +
-		`xmlns:owl="http://www.w3.org/2002/07/owl#"><owl:Ontology rdf:about=""/></rdf:RDF>`, 200, ".owl", "Good case, owl works"},
-	{httptest.NewRecorder(), "test.ttl", "@prefix : <#> .@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .", 200,
-		".ttl", "Good case, ttl works"},
-	{httptest.NewRecorder(), "test.html", "<!DOCTYPE html><html><head><title></title></head><body></body></html>",
-		200, ".html", "Good case, html works"},
-	{httptest.NewRecorder(), "test.csv", "id,name\n", 200, ".csv", "Good case, csv works"},
-	{httptest.NewRecorder(), "test.mp4", "\x00\x00\x00\x18\x66\x74\x79\x70\x69\x73\x6f\x6d\x00\x00\x02\x00\x69\x73\x6f\x6d\x69\x73\x6f\x32",
-		200, ".mp4", "Good case, mp4 works"},
-	{httptest.NewRecorder(), "test.txt", "Internal Server Error\n", 500, ".txt", "Bad case, parsing url fails"},
-	{httptest.NewRecorder(), "wrong.txt", "Not Found\n", 404, ".txt", "Bad case, file not found"},
-	{&mockResponseWriter{}, "test.txt", "Failed to serve requested file\n", 500, ".txt", "Bad case, copy fails"},
-}
-
-var dir = "./files"
-
-var minimalJPEG = []byte{0xFF, 0xD8}
-var minimalZIP = []byte{0x50, 0x4B, 0x03, 0x04}
-var minimalTXT = []byte("\n")
-var minimalOWL = []byte(`<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"` +
-	`xmlns:owl="http://www.w3.org/2002/07/owl#"><owl:Ontology rdf:about=""/></rdf:RDF>`)
-var minimalTTL = []byte("@prefix : <#> .@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .")
-var minimalHTML = []byte("<!DOCTYPE html><html><head><title></title></head><body></body></html>")
-var minimalCSV = []byte("id,name\n")
-var minimalMP4 = []byte{0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6F, 0x6D,
-	0x00, 0x00, 0x02, 0x00, 0x69, 0x73, 0x6F, 0x6D, 0x69, 0x73, 0x6F, 0x32}
-
-func createTestFolderAndFile(filename string, fileType string) {
-	fullPath := "./" + filepath.Join(dir, filename)
-	err := os.MkdirAll(dir, 0755)
-	if err != nil {
-		log.Fatalf("Error creating test directory: %v", err)
-		return
-	}
-
-	f, err := os.OpenFile(fullPath, os.O_CREATE|os.O_RDWR, 0600)
-	if err != nil {
-		if os.IsExist(err) {
-			log.Fatalf("File already exists: %v", err)
-		} else {
-			log.Fatalf("Error creating file: %v", err)
-		}
-		return
-	}
-	defer f.Close()
-
-	var data []byte
-	switch fileType {
-	case ".jpg", ".jpeg":
-		data = minimalJPEG
-	case ".zip":
-		data = minimalZIP
-	case ".txt":
-		data = minimalTXT
-	case ".owl":
-		data = minimalOWL
-	case ".ttl":
-		data = minimalTTL
-	case ".html", ".htm":
-		data = minimalHTML
-	case ".csv":
-		data = minimalCSV
-	case ".mp4":
-		data = minimalMP4
-	default:
-		log.Fatalf("Filetype is wrong")
-		return
-	}
-
-	err = os.WriteFile(fullPath, data, 0644)
-	if err != nil {
-		log.Fatalf("Error encoding to jpeg: %v", err)
-	}
-}
-
-func removeTestFolderAndFile(filename string) {
-	fullPath := "./" + filepath.Join(dir, filename)
-	if err := os.Remove(fullPath); err != nil {
-		log.Fatalf("Error deleting file: %v", err)
-	}
-	if err := os.Remove(dir); err != nil {
-		log.Fatalf("Error deleting directory: %v", err)
-	}
-}
-
-func TestTransferFile(t *testing.T) {
-	for _, testCase := range transferFileTestParams {
-		fullPath := "/" + filepath.Join(dir, testCase.filename)
-		inputR := httptest.NewRequest(http.MethodPost, fullPath, nil)
-		if testCase.testName == "Bad case, parsing url fails" {
-			inputR.URL.Path = "/foo%ZZbar"
-		}
-		if testCase.testName == "Bad case, file not found" {
-			inputR.URL.Path = "/files/doesNotExist.error"
-		}
-
-		createTestFolderAndFile(testCase.filename, testCase.fileType)
-		TransferFile(testCase.inputW, inputR)
-		removeTestFolderAndFile(testCase.filename)
-
-		if testCase.testName == "Bad case, copy fails" {
-			if _, ok := testCase.inputW.(*mockResponseWriter); !ok {
-				t.Errorf("Expected inputW to be of type *mockResponseWriter")
-			}
-		}
-
-		recorder, ok := testCase.inputW.(*httptest.ResponseRecorder)
-		if ok {
-			if recorder.Body.String() != testCase.expectedBody || recorder.Code != testCase.expectedCode {
-				t.Errorf("Expected: %s and %d, got: %s and %d", testCase.expectedBody, testCase.expectedCode, recorder.Body.String(), recorder.Code)
-			}
-		}
-	}
-}

From af31ad26ea787cf04559867f9ae31b0ccff5bae4 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 7 Jul 2025 10:13:00 +0200
Subject: [PATCH 123/186] Fixed some small stuff with the tests

---
 forms/file_forms.go      |  4 ++--
 forms/file_forms_test.go | 50 ++++++++++++++++++++++------------------
 2 files changed, 30 insertions(+), 24 deletions(-)

diff --git a/forms/file_forms.go b/forms/file_forms.go
index a6a4d53..d94fcdd 100644
--- a/forms/file_forms.go
+++ b/forms/file_forms.go
@@ -57,7 +57,7 @@ func init() {
 	FormTypeMap["FileForm_v1"] = reflect.TypeOf(FileForm_v1{})
 }
 
-const dirString string = "./files"
+const fileDir string = "files"
 
 // TransferFile enables the transfer of different types files when the filename is given in the URL
 func TransferFile(w http.ResponseWriter, r *http.Request) {
@@ -96,7 +96,7 @@ func TransferFile(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Open the requested file from the ./files directory
-	dir := http.Dir(dirString)
+	dir := http.Dir(fileDir)
 	reqFile, err := dir.Open(filename)
 	if err != nil {
 		log.Println("Requested file not found:", err)
diff --git a/forms/file_forms_test.go b/forms/file_forms_test.go
index c5e0469..950f7c5 100644
--- a/forms/file_forms_test.go
+++ b/forms/file_forms_test.go
@@ -2,7 +2,6 @@ package forms
 
 import (
 	"fmt"
-	"log"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -67,38 +66,31 @@ var fileTypeMap = map[string][]byte{
 		0x00, 0x00, 0x02, 0x00, 0x69, 0x73, 0x6F, 0x6D, 0x69, 0x73, 0x6F, 0x32},
 }
 
-func createTestFolderAndFile(filename string, fileType string) {
-	fullPath := filepath.Join(dirString, filename)
-	err := os.MkdirAll(dirString, 0755)
+func createTestFolderAndFile(filename string, fileType string) error {
+	fullPath := filepath.Join(fileDir, filename)
+	err := os.MkdirAll(fileDir, 0755)
 	if err != nil {
-		log.Fatalf("Error creating test directory: %v", err)
-		return
+		return err
 	}
 
 	f, err := os.OpenFile(fullPath, os.O_CREATE|os.O_RDWR, 0600)
 	if err != nil {
-		log.Fatalf("Error creating file: %v", err)
-		return
+		return err
 	}
 	defer f.Close()
 
-	err = os.WriteFile(fullPath, fileTypeMap[fileType], 0644)
-	if err != nil {
-		log.Fatalf("Error encoding to jpeg: %v", err)
-	}
+	return os.WriteFile(fullPath, fileTypeMap[fileType], 0644)
 }
 
-func removeTestFolderAndFile() {
-	if err := os.RemoveAll(dirString); err != nil {
-		log.Fatalf("Error deleting directory: %v", err)
-	}
+func removeTestFolderAndFile() error {
+	return os.RemoveAll(fileDir)
 }
 
 func TestTransferFile(t *testing.T) {
 	for _, testCase := range transferFileTestParams {
-		fullPath := "/" + path.Join(dirString, testCase.filename)
+		fileURL := "/" + path.Join(fileDir, testCase.filename)
 		inputW := httptest.NewRecorder()
-		inputR := httptest.NewRequest(http.MethodPost, fullPath, nil)
+		inputR := httptest.NewRequest(http.MethodPost, fileURL, nil)
 		if testCase.testName == "Bad case, parsing url fails" {
 			inputR.URL.Path = "/foo%ZZbar"
 		}
@@ -106,9 +98,16 @@ func TestTransferFile(t *testing.T) {
 			inputR.URL.Path = "/files/doesNotExist.error"
 		}
 
-		createTestFolderAndFile(testCase.filename, testCase.fileType)
+		err := createTestFolderAndFile(testCase.filename, testCase.fileType)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
 		TransferFile(inputW, inputR)
-		removeTestFolderAndFile()
+		err = removeTestFolderAndFile()
+		if err != nil {
+			t.Error(err)
+		}
 
 		if inputW.Body.String() != testCase.expectedBody || inputW.Code != testCase.expectedCode {
 			t.Errorf("Expected: %s and %d, got: %s and %d", testCase.expectedBody, testCase.expectedCode, inputW.Body.String(), inputW.Code)
@@ -119,9 +118,16 @@ func TestTransferFile(t *testing.T) {
 	fullPath := "/files/test.txt"
 	specialRecorder := &mockResponseWriter{}
 	inputR := httptest.NewRequest(http.MethodPost, fullPath, nil)
-	createTestFolderAndFile("test.txt", ".txt")
+	err := createTestFolderAndFile("test.txt", ".txt")
+	if err != nil {
+		t.Error(err)
+		return
+	}
 	TransferFile(specialRecorder, inputR)
-	removeTestFolderAndFile()
+	err = removeTestFolderAndFile()
+	if err != nil {
+		t.Error(err)
+	}
 
 	if specialRecorder.statusCode != 300 {
 		t.Errorf("Expected status code 300, got: %d", specialRecorder.statusCode)

From 18cabb032a05e5b9505543ae88516474cf147f91 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 7 Jul 2025 10:56:15 +0200
Subject: [PATCH 124/186] Added a test for file escape (reading a file you are
 not allowed to read)

---
 forms/file_forms_test.go | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/forms/file_forms_test.go b/forms/file_forms_test.go
index 950f7c5..afe7b06 100644
--- a/forms/file_forms_test.go
+++ b/forms/file_forms_test.go
@@ -133,3 +133,13 @@ func TestTransferFile(t *testing.T) {
 		t.Errorf("Expected status code 300, got: %d", specialRecorder.statusCode)
 	}
 }
+
+func TestFileEscape(t *testing.T) {
+	inputW := httptest.NewRecorder()
+	inputR := httptest.NewRequest(http.MethodPost, "http://localhost/../signal_forms.go", nil)
+	TransferFile(inputW, inputR)
+
+	if inputW.Code != 404 {
+		t.Errorf("Expected error code 404, got: %d", inputW.Code)
+	}
+}

From 1f8cd6456ab83f56bca9bf4a13cd71f55f191ff7 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 30 Jun 2025 08:39:45 +0200
Subject: [PATCH 125/186] Added test for GetActivitiesCost()

---
 usecases/cost_test.go | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 usecases/cost_test.go

diff --git a/usecases/cost_test.go b/usecases/cost_test.go
new file mode 100644
index 0000000..05e4698
--- /dev/null
+++ b/usecases/cost_test.go
@@ -0,0 +1,41 @@
+package usecases
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/sdoque/mbaigo/components"
+)
+
+// GetActivitiesCost(serv *components.Service) (payload []byte, err error)
+func TestGetActivitiesCost(t *testing.T) {
+	testServ := &components.Service{
+		Definition: "testDef",
+		ACost:      123,
+		CUnit:      "testCUnit",
+	}
+	data, err := GetActivitiesCost(testServ)
+	if err != nil {
+		t.Errorf("no error expected, got: %v", err)
+	}
+
+	// Check that correct data is present
+	if strings.Contains(string(data), `"activity": "testDef"`) == false {
+		t.Errorf("Definition/activity doesn't match")
+	}
+	if (strings.Contains(string(data), `"cost": 123`)) == false {
+		t.Errorf("ACost/cost doesn't match")
+	}
+}
+
+// SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error)
+func TestSetActivitiesCost(t *testing.T) {
+	// Forms, with and without version
+	// SwitchCase: formtype, ActivityCostForm_v1 or not
+	// Check if serv.Definition and ActivityCostForm.Activity is equal
+}
+
+// ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset, serviceP string)
+func TestACServices(t *testing.T) {
+
+}

From a7e87de7955f92040d66c53147c0be4a16c43c93 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 30 Jun 2025 11:49:28 +0200
Subject: [PATCH 126/186] First iteration of tests for SetActivitiesCost(...)

---
 usecases/cost_test.go | 90 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 87 insertions(+), 3 deletions(-)

diff --git a/usecases/cost_test.go b/usecases/cost_test.go
index 05e4698..0ffa085 100644
--- a/usecases/cost_test.go
+++ b/usecases/cost_test.go
@@ -1,10 +1,12 @@
 package usecases
 
 import (
+	"encoding/json"
 	"strings"
 	"testing"
 
 	"github.com/sdoque/mbaigo/components"
+	"github.com/sdoque/mbaigo/forms"
 )
 
 // GetActivitiesCost(serv *components.Service) (payload []byte, err error)
@@ -28,11 +30,93 @@ func TestGetActivitiesCost(t *testing.T) {
 	}
 }
 
+type setACparams struct {
+	createData  func() (data []byte, err error)
+	expectError bool
+	testCase    string
+}
+
+func createTestService() (serv *components.Service) {
+	testServ := &components.Service{
+		ID:            0,
+		Definition:    "testDefinition",
+		SubPath:       "testService",
+		Details:       map[string][]string{"Details": {"detail1", "detail2"}},
+		RegPeriod:     45,
+		RegTimestamp:  "Now",
+		RegExpiration: "Later",
+		Description:   "A service for testing purposes",
+		SubscribeAble: false,
+		ACost:         123,
+		CUnit:         "testCUnit",
+	}
+	return testServ
+}
+
+func createACFormBytes(definition string, version string, errRead bool) (data []byte, err error) {
+	var body interface{}
+	if errRead == true {
+		return json.Marshal(errReader(0))
+	}
+	if len(version) == 0 {
+		body = testBodyNoVersion{}
+	} else {
+		body = forms.ActivityCostForm_v1{Activity: definition, Cost: 321, Version: version}
+	}
+
+	data, err = json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
 // SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error)
 func TestSetActivitiesCost(t *testing.T) {
-	// Forms, with and without version
-	// SwitchCase: formtype, ActivityCostForm_v1 or not
-	// Check if serv.Definition and ActivityCostForm.Activity is equal
+	testParams := []setACparams{
+		// Best case: No errors
+		{func() (data []byte, err error) {
+			return createACFormBytes("testDefinition", "ActivityCostForm_v1", false)
+		}, false, "Best case, no errors"},
+		// Bad case: Fail @ unmarshal
+		{func() (data []byte, err error) {
+			return createACFormBytes("testDefinition", "ActivityCostForm_v1", true)
+		}, true, "Bad case, break first unmarshal"},
+		// Bad case: No version field in byte array
+		{func() (data []byte, err error) {
+			return createACFormBytes("testDefinition", "", false)
+		}, true, "Bad case, version missing"},
+		// Bad case: Unsupported version
+		{func() (data []byte, err error) {
+			return createACFormBytes("testDefinition", "wrongVersion", false)
+		}, true, "Bad case, unsupported version"},
+		// Bad case: mismatch between 'serv.Definition' and 'acForm.Activity'
+		{func() (data []byte, err error) {
+			return createACFormBytes("", "ActivityCostForm_v1", false)
+		}, true, "Bad case, serv.Definition != acForm.Activity"},
+		// TODO: Add testcase to test 2nd unmarshal 'Bad case: Fail @ 2nd unmarshal'
+	}
+	testServ := createTestService()
+
+	for _, c := range testParams {
+		// Setup
+		byteArr, err := c.createData()
+		if err != nil {
+			t.Errorf("failed while creating byte array in setup of testcase '%s'", c.testCase)
+		}
+
+		// Test
+		err = SetActivitiesCost(testServ, byteArr)
+		if c.expectError != true {
+			if err != nil {
+				t.Errorf("Expected no errors in testcase '%s', got: %v", c.testCase, err)
+			}
+		} else {
+			if err == nil {
+				t.Errorf("Expected errors in testcase '%s'", c.testCase)
+			}
+		}
+	}
 }
 
 // ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset, serviceP string)

From b1d12362e648ddc140f991e6a1ffec09ceef7dc4 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 30 Jun 2025 11:55:28 +0200
Subject: [PATCH 127/186] Forgot to add changes to cost.go file

---
 usecases/cost.go | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/usecases/cost.go b/usecases/cost.go
index e4eed2f..7e64398 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -21,7 +21,7 @@ package usecases
 
 import (
 	"encoding/json"
-	"errors"
+	"fmt"
 	"io"
 	"log"
 	"net/http"
@@ -47,13 +47,13 @@ func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		log.Printf("Error unmarshalling JSON data: %v", err)
-		return
+		//log.Printf("Error unmarshalling JSON data: %v", err)
+		return fmt.Errorf("error unmarshalling JSON data: %v", err)
 	}
 	formVersion, ok := jsonData["version"].(string)
 	if !ok {
-		log.Printf("Error: 'version' key not found in JSON data")
-		return
+		//log.Printf("Error: 'version' key not found in JSON data")
+		return fmt.Errorf("'version' key not found in JSON data")
 	}
 	var acForm forms.ActivityCostForm_v1
 	switch formVersion {
@@ -61,21 +61,24 @@ func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
 		var f forms.ActivityCostForm_v1
 		err = json.Unmarshal(bodyBytes, &f)
 		if err != nil {
-			log.Println("Unable to extract new activity costs request ")
-			return
+			//log.Println("Unable to extract new activity costs request ")
+			//return
+			return fmt.Errorf("unable to extract new activity costs request ")
 		}
 		acForm = f
 	default:
-		err = errors.New("unsupported version of activity costs form")
-		return
+		//err = errors.New("unsupported version of activity costs form")
+		//return
+		return fmt.Errorf("unsupported version of activity costs form")
 	}
 
 	if serv.Definition == acForm.Activity {
 		serv.ACost = acForm.Cost // update the service's cost
 		log.Printf("The new service cost is %f => the service is %+v\n", acForm.Cost, serv)
 	} else {
-		err = errors.New("mismatch between service list order") // corrected typo
-		return
+		//err = errors.New("mismatch between service list order") // corrected typo
+		//return
+		return fmt.Errorf("mismatch between service list order")
 	}
 	return
 }

From 2d9c7c2d8a86245c75d290afb3fcf21da808a763 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 30 Jun 2025 14:38:44 +0200
Subject: [PATCH 128/186] Simplified SetActivitiesCost() test

---
 usecases/cost_test.go | 53 ++++++++-----------------------------------
 1 file changed, 9 insertions(+), 44 deletions(-)

diff --git a/usecases/cost_test.go b/usecases/cost_test.go
index 0ffa085..3da769e 100644
--- a/usecases/cost_test.go
+++ b/usecases/cost_test.go
@@ -1,12 +1,10 @@
 package usecases
 
 import (
-	"encoding/json"
 	"strings"
 	"testing"
 
 	"github.com/sdoque/mbaigo/components"
-	"github.com/sdoque/mbaigo/forms"
 )
 
 // GetActivitiesCost(serv *components.Service) (payload []byte, err error)
@@ -31,7 +29,7 @@ func TestGetActivitiesCost(t *testing.T) {
 }
 
 type setACparams struct {
-	createData  func() (data []byte, err error)
+	dataString  string
 	expectError bool
 	testCase    string
 }
@@ -53,60 +51,27 @@ func createTestService() (serv *components.Service) {
 	return testServ
 }
 
-func createACFormBytes(definition string, version string, errRead bool) (data []byte, err error) {
-	var body interface{}
-	if errRead == true {
-		return json.Marshal(errReader(0))
-	}
-	if len(version) == 0 {
-		body = testBodyNoVersion{}
-	} else {
-		body = forms.ActivityCostForm_v1{Activity: definition, Cost: 321, Version: version}
-	}
-
-	data, err = json.Marshal(body)
-	if err != nil {
-		return nil, err
-	}
-	return data, nil
-}
-
 // SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error)
 func TestSetActivitiesCost(t *testing.T) {
 	testParams := []setACparams{
 		// Best case: No errors
-		{func() (data []byte, err error) {
-			return createACFormBytes("testDefinition", "ActivityCostForm_v1", false)
-		}, false, "Best case, no errors"},
+		{`{"activity":"testDefinition","cost":321,"unit":"","timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`, false, "Best case, no errors"},
 		// Bad case: Fail @ unmarshal
-		{func() (data []byte, err error) {
-			return createACFormBytes("testDefinition", "ActivityCostForm_v1", true)
-		}, true, "Bad case, break first unmarshal"},
+		{"", true, "Bad case, break first unmarshal"},
 		// Bad case: No version field in byte array
-		{func() (data []byte, err error) {
-			return createACFormBytes("testDefinition", "", false)
-		}, true, "Bad case, version missing"},
+		{`{"activity":"testDefinition","cost":321,"unit":"","timestamp":"0001-01-01T00:00:00Z"}`, true, "Bad case, version missing"},
 		// Bad case: Unsupported version
-		{func() (data []byte, err error) {
-			return createACFormBytes("testDefinition", "wrongVersion", false)
-		}, true, "Bad case, unsupported version"},
+		{`{"activity":"testDefinition","cost":321,"unit":"","timestamp":"0001-01-01T00:00:00Z","version":"WrongVersion"}`, true, "Bad case, unsupported version"},
 		// Bad case: mismatch between 'serv.Definition' and 'acForm.Activity'
-		{func() (data []byte, err error) {
-			return createACFormBytes("", "ActivityCostForm_v1", false)
-		}, true, "Bad case, serv.Definition != acForm.Activity"},
-		// TODO: Add testcase to test 2nd unmarshal 'Bad case: Fail @ 2nd unmarshal'
+		{`{"activity":"WrongDef","cost":321,"unit":"","timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`, true, "Bad case, serv.Definition != acForm.Activity"},
+		// Bad case: Fail @ 2nd unmarshal
+		{`{"activity":"testDefinition","cost":"321","unit":"","timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`, true, "Bad case, break first unmarshal"},
 	}
 	testServ := createTestService()
 
 	for _, c := range testParams {
-		// Setup
-		byteArr, err := c.createData()
-		if err != nil {
-			t.Errorf("failed while creating byte array in setup of testcase '%s'", c.testCase)
-		}
-
 		// Test
-		err = SetActivitiesCost(testServ, byteArr)
+		err := SetActivitiesCost(testServ, []byte(c.dataString))
 		if c.expectError != true {
 			if err != nil {
 				t.Errorf("Expected no errors in testcase '%s', got: %v", c.testCase, err)

From c82624a96134975cdb77c72cfe76ac525abca082 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 30 Jun 2025 14:42:52 +0200
Subject: [PATCH 129/186] Removed commented out code and prints

---
 usecases/cost.go | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/usecases/cost.go b/usecases/cost.go
index 7e64398..dce8636 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -47,12 +47,10 @@ func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		//log.Printf("Error unmarshalling JSON data: %v", err)
 		return fmt.Errorf("error unmarshalling JSON data: %v", err)
 	}
 	formVersion, ok := jsonData["version"].(string)
 	if !ok {
-		//log.Printf("Error: 'version' key not found in JSON data")
 		return fmt.Errorf("'version' key not found in JSON data")
 	}
 	var acForm forms.ActivityCostForm_v1
@@ -61,23 +59,16 @@ func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
 		var f forms.ActivityCostForm_v1
 		err = json.Unmarshal(bodyBytes, &f)
 		if err != nil {
-			//log.Println("Unable to extract new activity costs request ")
-			//return
 			return fmt.Errorf("unable to extract new activity costs request ")
 		}
 		acForm = f
 	default:
-		//err = errors.New("unsupported version of activity costs form")
-		//return
 		return fmt.Errorf("unsupported version of activity costs form")
 	}
 
 	if serv.Definition == acForm.Activity {
 		serv.ACost = acForm.Cost // update the service's cost
-		log.Printf("The new service cost is %f => the service is %+v\n", acForm.Cost, serv)
 	} else {
-		//err = errors.New("mismatch between service list order") // corrected typo
-		//return
 		return fmt.Errorf("mismatch between service list order")
 	}
 	return

From 872d883e7cf20ac67254ea0ecf1cdacf25394dbc Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 30 Jun 2025 17:41:38 +0200
Subject: [PATCH 130/186] Removed commented out code, and sends error message
 instead

---
 usecases/cost.go | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/usecases/cost.go b/usecases/cost.go
index dce8636..b67d952 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -23,7 +23,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"net/http"
 	"time"
 
@@ -82,7 +81,6 @@ func ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset
 	case "GET":
 		payload, err := GetActivitiesCost(serv)
 		if err != nil {
-			log.Printf("Error in getting the activity costs\n")
 			http.Error(w, "Error marshaling data.", http.StatusInternalServerError)
 			return
 		}
@@ -90,19 +88,19 @@ func ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset
 		w.WriteHeader(http.StatusOK)
 		_, err = w.Write(payload)
 		if err != nil {
-			log.Printf("Error while writing to response body for ACServices: %v", err)
+			http.Error(w, "Error while writing to response body", http.StatusInternalServerError)
 		}
 		return
 	case "PUT":
 		defer r.Body.Close()
 		bodyBytes, err := io.ReadAll(r.Body) // Use io.ReadAll instead of ioutil.ReadAll
 		if err != nil {
-			log.Printf("Error reading registration response body: %v", err)
+			http.Error(w, "Error reading registration response body", http.StatusBadRequest)
 			return
 		}
 		err = SetActivitiesCost(serv, bodyBytes)
 		if err != nil {
-			log.Printf("there was an error updating the activittiy costs, %s\n", err)
+			http.Error(w, "Error occured while updating activity costs", http.StatusInternalServerError)
 		}
 	default:
 		http.Error(w, "Method is not supported.", http.StatusNotFound)

From d80bd9895f3643dd149355946ea84ea7429f0c47 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 30 Jun 2025 17:45:47 +0200
Subject: [PATCH 131/186] Created help func, added first tests of ACServices()

---
 usecases/cost_test.go | 62 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/usecases/cost_test.go b/usecases/cost_test.go
index 3da769e..89c64ab 100644
--- a/usecases/cost_test.go
+++ b/usecases/cost_test.go
@@ -1,6 +1,8 @@
 package usecases
 
 import (
+	"io"
+	"net/http/httptest"
 	"strings"
 	"testing"
 
@@ -84,7 +86,67 @@ func TestSetActivitiesCost(t *testing.T) {
 	}
 }
 
+// Creates a unitasset with values used for testing
+func createUnitAsset() components.UnitAsset {
+	setTest := &components.Service{
+		ID:            1,
+		Definition:    "test",
+		SubPath:       "test",
+		Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
+		Description:   "A test service",
+		RegPeriod:     45,
+		RegTimestamp:  "now",
+		RegExpiration: "45",
+	}
+	ServicesMap := &components.Services{
+		setTest.SubPath: setTest,
+	}
+	var ua components.UnitAsset
+	ua = &mockUnitAsset{
+		Name:        "testUnitAsset",
+		Details:     map[string][]string{"Test": {"Test"}},
+		ServicesMap: *ServicesMap,
+		CervicesMap: nil,
+	}
+	return ua
+}
+
+type acServicesParams struct {
+	httpMethod  string
+	expectError bool
+	body        string
+	testCase    string
+}
+
 // ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset, serviceP string)
 func TestACServices(t *testing.T) {
+	testParams := []acServicesParams{
+		// Good case: no errors in GET/PUT
+		{"GET", false, "", "Best case: no errors in GET"},
+		{"PUT", false, `{"activity":"test", "cost": 321, "version":"ActivityCostForm_v1"}`, "Best case: no errors in PUT"},
+		// GET, Bad case: GetActivitiesCost() returns error
+		// GET, Bad case: Couldn't write to responsewriter
+		// PUT, Bad case: Reading response body returns an error
+		// PUT, Bad case: SetActivitesCost() returns error
+		// DEFAULT: Method not supported (POST)
+	}
 
+	for _, c := range testParams {
+		// Setup
+		ua := createUnitAsset()
+		w := httptest.NewRecorder()
+		body := io.NopCloser(strings.NewReader(c.body))
+		r := httptest.NewRequest(c.httpMethod, "http://localhost", body)
+		// Test
+		ACServices(w, r, &ua, "test")
+		if c.expectError == false {
+			if w.Result().StatusCode != 200 {
+				t.Errorf("Expected no errors in '%s'", c.testCase)
+			}
+		} else {
+			if r.Response.StatusCode == 200 {
+				t.Errorf("Expected errors in testcase '%s'", c.testCase)
+			}
+		}
+	}
 }

From 3f10766de854409e92ec1d1466f1d8ee8ac04702 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 30 Jun 2025 17:49:31 +0200
Subject: [PATCH 132/186] fixed spellcheck errors

---
 usecases/cost.go      | 2 +-
 usecases/cost_test.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/usecases/cost.go b/usecases/cost.go
index b67d952..e467af2 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -100,7 +100,7 @@ func ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset
 		}
 		err = SetActivitiesCost(serv, bodyBytes)
 		if err != nil {
-			http.Error(w, "Error occured while updating activity costs", http.StatusInternalServerError)
+			http.Error(w, "Error occurred while updating activity costs", http.StatusInternalServerError)
 		}
 	default:
 		http.Error(w, "Method is not supported.", http.StatusNotFound)
diff --git a/usecases/cost_test.go b/usecases/cost_test.go
index 89c64ab..9e25a15 100644
--- a/usecases/cost_test.go
+++ b/usecases/cost_test.go
@@ -127,7 +127,7 @@ func TestACServices(t *testing.T) {
 		// GET, Bad case: GetActivitiesCost() returns error
 		// GET, Bad case: Couldn't write to responsewriter
 		// PUT, Bad case: Reading response body returns an error
-		// PUT, Bad case: SetActivitesCost() returns error
+		// PUT, Bad case: SetActivitiesCost() returns error
 		// DEFAULT: Method not supported (POST)
 	}
 

From f17a38aa1bd209eddbf4b1a49e2b4398805e8c19 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 1 Jul 2025 13:07:28 +0200
Subject: [PATCH 133/186] Finished tests for usecases/cost.go

---
 usecases/cost_test.go | 69 ++++++++++++++++++++++++++++++-------------
 1 file changed, 48 insertions(+), 21 deletions(-)

diff --git a/usecases/cost_test.go b/usecases/cost_test.go
index 9e25a15..48d4416 100644
--- a/usecases/cost_test.go
+++ b/usecases/cost_test.go
@@ -2,6 +2,8 @@ package usecases
 
 import (
 	"io"
+	"math"
+	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
@@ -30,6 +32,10 @@ func TestGetActivitiesCost(t *testing.T) {
 	}
 }
 
+// ------------------------------------------------------ //
+// Helper functions and structs for TestSetActivitesCost()
+// ------------------------------------------------------ //
+
 type setACparams struct {
 	dataString  string
 	expectError bool
@@ -86,8 +92,12 @@ func TestSetActivitiesCost(t *testing.T) {
 	}
 }
 
+// ------------------------------------------------------ //
+// Helper functions and structs for TestACServices()
+// ------------------------------------------------------ //
+
 // Creates a unitasset with values used for testing
-func createUnitAsset() components.UnitAsset {
+func createUnitAsset(cost float64) components.UnitAsset {
 	setTest := &components.Service{
 		ID:            1,
 		Definition:    "test",
@@ -97,12 +107,13 @@ func createUnitAsset() components.UnitAsset {
 		RegPeriod:     45,
 		RegTimestamp:  "now",
 		RegExpiration: "45",
+		ACost:         cost,
 	}
 	ServicesMap := &components.Services{
 		setTest.SubPath: setTest,
 	}
-	var ua components.UnitAsset
-	ua = &mockUnitAsset{
+	//var ua components.UnitAsset
+	var ua components.UnitAsset = &mockUnitAsset{
 		Name:        "testUnitAsset",
 		Details:     map[string][]string{"Test": {"Test"}},
 		ServicesMap: *ServicesMap,
@@ -112,40 +123,56 @@ func createUnitAsset() components.UnitAsset {
 }
 
 type acServicesParams struct {
-	httpMethod  string
-	expectError bool
-	body        string
-	testCase    string
+	httpMethod     string
+	responseWriter *httptest.ResponseRecorder
+	expectError    bool
+	request        *http.Request
+	unitAsset      components.UnitAsset
+	testCase       string
 }
 
 // ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset, serviceP string)
 func TestACServices(t *testing.T) {
 	testParams := []acServicesParams{
 		// Good case: no errors in GET/PUT
-		{"GET", false, "", "Best case: no errors in GET"},
-		{"PUT", false, `{"activity":"test", "cost": 321, "version":"ActivityCostForm_v1"}`, "Best case: no errors in PUT"},
+		{"GET", httptest.NewRecorder(), false, httptest.NewRequest(http.MethodGet, "http://localhost", io.NopCloser(strings.NewReader(``))), createUnitAsset(0), "GET, Best case: no errors in GET"},
+		{"PUT", httptest.NewRecorder(), false, httptest.NewRequest(http.MethodPut, "http://localhost", io.NopCloser(strings.NewReader(`{"activity":"test", "cost": 321, "version":"ActivityCostForm_v1"}`))), createUnitAsset(0), "PUT, Best case: no errors in PUT"},
 		// GET, Bad case: GetActivitiesCost() returns error
-		// GET, Bad case: Couldn't write to responsewriter
+		{"GET", httptest.NewRecorder(), true, httptest.NewRequest(http.MethodGet, "http://localhost", io.NopCloser(strings.NewReader(``))), createUnitAsset(math.NaN()), "GET, Bad case: error from GetActivitiesCost()"},
 		// PUT, Bad case: Reading response body returns an error
+		{"PUT", httptest.NewRecorder(), true, httptest.NewRequest(http.MethodPut, "http://localhost", io.NopCloser(errReader(0))), createUnitAsset(0), "PUT, Bad case: reading response body"},
 		// PUT, Bad case: SetActivitiesCost() returns error
-		// DEFAULT: Method not supported (POST)
+		{"PUT", httptest.NewRecorder(), true, httptest.NewRequest(http.MethodPut, "http://localhost", io.NopCloser(strings.NewReader(``))), createUnitAsset(0), "PUT, Bad case: error updating activities cost"},
+		// DEFAULT: Method not supported (POST),
+		{"POST", httptest.NewRecorder(), true, httptest.NewRequest(http.MethodPost, "http://localhost", io.NopCloser(strings.NewReader(``))), createUnitAsset(0), "POST, Bad case: Method not supported"},
+		// TODO: GET, Bad case: Couldn't write to responsewriter
 	}
 
 	for _, c := range testParams {
 		// Setup
-		ua := createUnitAsset()
-		w := httptest.NewRecorder()
-		body := io.NopCloser(strings.NewReader(c.body))
-		r := httptest.NewRequest(c.httpMethod, "http://localhost", body)
+		ua := c.unitAsset
+		w := c.responseWriter
+		r := c.request
 		// Test
 		ACServices(w, r, &ua, "test")
-		if c.expectError == false {
-			if w.Result().StatusCode != 200 {
-				t.Errorf("Expected no errors in '%s'", c.testCase)
+		switch c.httpMethod {
+		case "GET":
+			if c.expectError == false && w.Result().StatusCode != 200 {
+				t.Errorf("Expected statuscode 200 in testcase '%s'", c.testCase)
 			}
-		} else {
-			if r.Response.StatusCode == 200 {
-				t.Errorf("Expected errors in testcase '%s'", c.testCase)
+			if c.expectError == true && w.Result().StatusCode == 200 {
+				t.Errorf("Expected statuscode not to be 200 in testcase '%s'", c.testCase)
+			}
+		case "PUT":
+			if c.expectError == false && w.Result().StatusCode != 200 {
+				t.Errorf("Expected statuscode 200 in testcase '%s' got: %d", c.testCase, w.Result().StatusCode)
+			}
+			if c.expectError == true && w.Result().StatusCode == 200 {
+				t.Errorf("Expected statuscode not to be 200 in testcase '%s'", c.testCase)
+			}
+		default:
+			if w.Result().StatusCode == 200 {
+				t.Errorf("Expected error code, got %d", r.Response.StatusCode)
 			}
 		}
 	}

From e9a0a3d7b6c39234448af24fe4ce64bb1ae9a3d3 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 1 Jul 2025 13:09:20 +0200
Subject: [PATCH 134/186] Fixed typo

---
 usecases/cost_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/cost_test.go b/usecases/cost_test.go
index 48d4416..b20d441 100644
--- a/usecases/cost_test.go
+++ b/usecases/cost_test.go
@@ -33,7 +33,7 @@ func TestGetActivitiesCost(t *testing.T) {
 }
 
 // ------------------------------------------------------ //
-// Helper functions and structs for TestSetActivitesCost()
+// Helper functions and structs for TestSetActivitiesCost()
 // ------------------------------------------------------ //
 
 type setACparams struct {

From 20f93fbeb0aaa0850eeed6c941aa51c2d3c4331b Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Tue, 1 Jul 2025 19:13:15 +0200
Subject: [PATCH 135/186] Fixed error string in cost.go, and simplified error
 handler in TestSetActivitiesCost()

---
 usecases/cost.go      |  2 +-
 usecases/cost_test.go | 11 +++--------
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/usecases/cost.go b/usecases/cost.go
index e467af2..f132968 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -46,7 +46,7 @@ func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		return fmt.Errorf("error unmarshalling JSON data: %v", err)
+		return fmt.Errorf("unmarshalling JSON data: %w", err)
 	}
 	formVersion, ok := jsonData["version"].(string)
 	if !ok {
diff --git a/usecases/cost_test.go b/usecases/cost_test.go
index b20d441..096f863 100644
--- a/usecases/cost_test.go
+++ b/usecases/cost_test.go
@@ -80,14 +80,9 @@ func TestSetActivitiesCost(t *testing.T) {
 	for _, c := range testParams {
 		// Test
 		err := SetActivitiesCost(testServ, []byte(c.dataString))
-		if c.expectError != true {
-			if err != nil {
-				t.Errorf("Expected no errors in testcase '%s', got: %v", c.testCase, err)
-			}
-		} else {
-			if err == nil {
-				t.Errorf("Expected errors in testcase '%s'", c.testCase)
-			}
+
+		if (c.expectError == true && err == nil) || (c.expectError == false && err != nil) {
+			t.Errorf("Testcase '%s' failed, expectError was %v error was: %v", c.testCase, c.expectError, err)
 		}
 	}
 }

From 2d4ef06e59624af19c411a87e0962a8b6628630b Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Thu, 3 Jul 2025 19:20:45 +0200
Subject: [PATCH 136/186] Simplified TestACServices() slightly, reduced line
 lengths & fixed most PR comments

---
 usecases/cost.go      |  15 +++---
 usecases/cost_test.go | 104 ++++++++++++++++++++++++++++--------------
 2 files changed, 76 insertions(+), 43 deletions(-)

diff --git a/usecases/cost.go b/usecases/cost.go
index f132968..a980917 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -46,7 +46,7 @@ func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
 	var jsonData map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &jsonData)
 	if err != nil {
-		return fmt.Errorf("unmarshalling JSON data: %w", err)
+		return fmt.Errorf("unmarshalling cost form: %w", err)
 	}
 	formVersion, ok := jsonData["version"].(string)
 	if !ok {
@@ -58,18 +58,18 @@ func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
 		var f forms.ActivityCostForm_v1
 		err = json.Unmarshal(bodyBytes, &f)
 		if err != nil {
-			return fmt.Errorf("unable to extract new activity costs request ")
+			return fmt.Errorf("unmarshalling cost form: %w", err)
 		}
 		acForm = f
 	default:
-		return fmt.Errorf("unsupported version of activity costs form")
+		return fmt.Errorf("unsupported version of activity costs form: %s", formVersion)
 	}
 
-	if serv.Definition == acForm.Activity {
-		serv.ACost = acForm.Cost // update the service's cost
-	} else {
-		return fmt.Errorf("mismatch between service list order")
+	if serv.Definition != acForm.Activity {
+		return fmt.Errorf("service definition and activity cost forms activity field doesn't match")
+
 	}
+	serv.ACost = acForm.Cost // update the service's cost
 	return
 }
 
@@ -90,7 +90,6 @@ func ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset
 		if err != nil {
 			http.Error(w, "Error while writing to response body", http.StatusInternalServerError)
 		}
-		return
 	case "PUT":
 		defer r.Body.Close()
 		bodyBytes, err := io.ReadAll(r.Body) // Use io.ReadAll instead of ioutil.ReadAll
diff --git a/usecases/cost_test.go b/usecases/cost_test.go
index 096f863..d9ee4ad 100644
--- a/usecases/cost_test.go
+++ b/usecases/cost_test.go
@@ -11,7 +11,6 @@ import (
 	"github.com/sdoque/mbaigo/components"
 )
 
-// GetActivitiesCost(serv *components.Service) (payload []byte, err error)
 func TestGetActivitiesCost(t *testing.T) {
 	testServ := &components.Service{
 		Definition: "testDef",
@@ -59,26 +58,43 @@ func createTestService() (serv *components.Service) {
 	return testServ
 }
 
-// SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error)
 func TestSetActivitiesCost(t *testing.T) {
 	testParams := []setACparams{
 		// Best case: No errors
-		{`{"activity":"testDefinition","cost":321,"unit":"","timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`, false, "Best case, no errors"},
+		{
+			`{"activity":"testDefinition","cost":321,"unit":"",
+			"timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`,
+			false, "Best case, no errors",
+		},
 		// Bad case: Fail @ unmarshal
 		{"", true, "Bad case, break first unmarshal"},
 		// Bad case: No version field in byte array
-		{`{"activity":"testDefinition","cost":321,"unit":"","timestamp":"0001-01-01T00:00:00Z"}`, true, "Bad case, version missing"},
+		{
+			`{"activity":"testDefinition","cost":321,"unit":"","timestamp":"0001-01-01T00:00:00Z"}`,
+			true, "Bad case, version missing",
+		},
 		// Bad case: Unsupported version
-		{`{"activity":"testDefinition","cost":321,"unit":"","timestamp":"0001-01-01T00:00:00Z","version":"WrongVersion"}`, true, "Bad case, unsupported version"},
+		{
+			`{"activity":"testDefinition","cost":321,"unit":"",
+			"timestamp":"0001-01-01T00:00:00Z","version":"WrongVersion"}`,
+			true, "Bad case, unsupported version",
+		},
 		// Bad case: mismatch between 'serv.Definition' and 'acForm.Activity'
-		{`{"activity":"WrongDef","cost":321,"unit":"","timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`, true, "Bad case, serv.Definition != acForm.Activity"},
+		{
+			`{"activity":"WrongDef","cost":321,"unit":"",
+			"timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`,
+			true, "Bad case, serv.Definition != acForm.Activity",
+		},
 		// Bad case: Fail @ 2nd unmarshal
-		{`{"activity":"testDefinition","cost":"321","unit":"","timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`, true, "Bad case, break first unmarshal"},
+		{
+			`{"activity":"testDefinition","cost":"321","unit":"",
+			"timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`,
+			true, "Bad case, break first unmarshal",
+		},
 	}
 	testServ := createTestService()
 
 	for _, c := range testParams {
-		// Test
 		err := SetActivitiesCost(testServ, []byte(c.dataString))
 
 		if (c.expectError == true && err == nil) || (c.expectError == false && err != nil) {
@@ -107,7 +123,6 @@ func createUnitAsset(cost float64) components.UnitAsset {
 	ServicesMap := &components.Services{
 		setTest.SubPath: setTest,
 	}
-	//var ua components.UnitAsset
 	var ua components.UnitAsset = &mockUnitAsset{
 		Name:        "testUnitAsset",
 		Details:     map[string][]string{"Test": {"Test"}},
@@ -126,20 +141,52 @@ type acServicesParams struct {
 	testCase       string
 }
 
-// ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset, serviceP string)
 func TestACServices(t *testing.T) {
 	testParams := []acServicesParams{
 		// Good case: no errors in GET/PUT
-		{"GET", httptest.NewRecorder(), false, httptest.NewRequest(http.MethodGet, "http://localhost", io.NopCloser(strings.NewReader(``))), createUnitAsset(0), "GET, Best case: no errors in GET"},
-		{"PUT", httptest.NewRecorder(), false, httptest.NewRequest(http.MethodPut, "http://localhost", io.NopCloser(strings.NewReader(`{"activity":"test", "cost": 321, "version":"ActivityCostForm_v1"}`))), createUnitAsset(0), "PUT, Best case: no errors in PUT"},
+		{
+			"GET", httptest.NewRecorder(), false,
+			httptest.NewRequest(
+				http.MethodGet,
+				"http://localhost",
+				io.NopCloser(strings.NewReader(``)),
+			),
+			createUnitAsset(0), "GET, Best case: no errors in GET",
+		},
+		{
+			"PUT", httptest.NewRecorder(), false,
+			httptest.NewRequest(
+				http.MethodPut,
+				"http://localhost",
+				io.NopCloser(strings.NewReader(
+					`{"activity":"test", "cost": 321, "version":"ActivityCostForm_v1"}`,
+				)),
+			),
+			createUnitAsset(0), "PUT, Best case: no errors in PUT",
+		},
 		// GET, Bad case: GetActivitiesCost() returns error
-		{"GET", httptest.NewRecorder(), true, httptest.NewRequest(http.MethodGet, "http://localhost", io.NopCloser(strings.NewReader(``))), createUnitAsset(math.NaN()), "GET, Bad case: error from GetActivitiesCost()"},
+		{
+			"GET", httptest.NewRecorder(), true,
+			httptest.NewRequest(http.MethodGet, "http://localhost", io.NopCloser(strings.NewReader(``))),
+			createUnitAsset(math.NaN()), "GET, Bad case: error from GetActivitiesCost()"},
 		// PUT, Bad case: Reading response body returns an error
-		{"PUT", httptest.NewRecorder(), true, httptest.NewRequest(http.MethodPut, "http://localhost", io.NopCloser(errReader(0))), createUnitAsset(0), "PUT, Bad case: reading response body"},
+		{
+			"PUT", httptest.NewRecorder(), true,
+			httptest.NewRequest(http.MethodPut, "http://localhost", io.NopCloser(errReader(0))),
+			createUnitAsset(0), "PUT, Bad case: reading response body",
+		},
 		// PUT, Bad case: SetActivitiesCost() returns error
-		{"PUT", httptest.NewRecorder(), true, httptest.NewRequest(http.MethodPut, "http://localhost", io.NopCloser(strings.NewReader(``))), createUnitAsset(0), "PUT, Bad case: error updating activities cost"},
+		{
+			"PUT", httptest.NewRecorder(), true,
+			httptest.NewRequest(http.MethodPut, "http://localhost", io.NopCloser(strings.NewReader(``))),
+			createUnitAsset(0), "PUT, Bad case: error updating activities cost",
+		},
 		// DEFAULT: Method not supported (POST),
-		{"POST", httptest.NewRecorder(), true, httptest.NewRequest(http.MethodPost, "http://localhost", io.NopCloser(strings.NewReader(``))), createUnitAsset(0), "POST, Bad case: Method not supported"},
+		{
+			"POST", httptest.NewRecorder(), true,
+			httptest.NewRequest(http.MethodPost, "http://localhost", io.NopCloser(strings.NewReader(``))),
+			createUnitAsset(0), "POST, Bad case: Method not supported",
+		},
 		// TODO: GET, Bad case: Couldn't write to responsewriter
 	}
 
@@ -150,25 +197,12 @@ func TestACServices(t *testing.T) {
 		r := c.request
 		// Test
 		ACServices(w, r, &ua, "test")
-		switch c.httpMethod {
-		case "GET":
-			if c.expectError == false && w.Result().StatusCode != 200 {
-				t.Errorf("Expected statuscode 200 in testcase '%s'", c.testCase)
-			}
-			if c.expectError == true && w.Result().StatusCode == 200 {
-				t.Errorf("Expected statuscode not to be 200 in testcase '%s'", c.testCase)
-			}
-		case "PUT":
-			if c.expectError == false && w.Result().StatusCode != 200 {
-				t.Errorf("Expected statuscode 200 in testcase '%s' got: %d", c.testCase, w.Result().StatusCode)
-			}
-			if c.expectError == true && w.Result().StatusCode == 200 {
-				t.Errorf("Expected statuscode not to be 200 in testcase '%s'", c.testCase)
-			}
-		default:
-			if w.Result().StatusCode == 200 {
-				t.Errorf("Expected error code, got %d", r.Response.StatusCode)
-			}
+
+		if c.expectError == false && w.Result().StatusCode != 200 {
+			t.Errorf("Expected statuscode 200 in testcase '%s' got: %d", c.testCase, w.Result().StatusCode)
+		}
+		if c.expectError == true && w.Result().StatusCode == 200 {
+			t.Errorf("Expected statuscode not to be 200 in testcase '%s'", c.testCase)
 		}
 	}
 }

From cae51cc1a213594bba76b6e481779a1d732218a1 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Fri, 4 Jul 2025 17:51:23 +0200
Subject: [PATCH 137/186] refactored code, and added last testcase for
 SetActivitiesCost()

---
 usecases/cost.go      | 21 +++------------------
 usecases/cost_test.go |  8 +++++++-
 2 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/usecases/cost.go b/usecases/cost.go
index a980917..c47c239 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -43,31 +43,16 @@ func GetActivitiesCost(serv *components.Service) (payload []byte, err error) {
 
 // SetActivitiesCost updates the service cost
 func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
-	var jsonData map[string]interface{}
-	err = json.Unmarshal(bodyBytes, &jsonData)
+	f, err := Unpack(bodyBytes, "application/json")
 	if err != nil {
 		return fmt.Errorf("unmarshalling cost form: %w", err)
 	}
-	formVersion, ok := jsonData["version"].(string)
+	acForm, ok := f.(*forms.ActivityCostForm_v1)
 	if !ok {
-		return fmt.Errorf("'version' key not found in JSON data")
+		return fmt.Errorf("couldn't convert to correct form")
 	}
-	var acForm forms.ActivityCostForm_v1
-	switch formVersion {
-	case "ActivityCostForm_v1":
-		var f forms.ActivityCostForm_v1
-		err = json.Unmarshal(bodyBytes, &f)
-		if err != nil {
-			return fmt.Errorf("unmarshalling cost form: %w", err)
-		}
-		acForm = f
-	default:
-		return fmt.Errorf("unsupported version of activity costs form: %s", formVersion)
-	}
-
 	if serv.Definition != acForm.Activity {
 		return fmt.Errorf("service definition and activity cost forms activity field doesn't match")
-
 	}
 	serv.ACost = acForm.Cost // update the service's cost
 	return
diff --git a/usecases/cost_test.go b/usecases/cost_test.go
index d9ee4ad..6af83ea 100644
--- a/usecases/cost_test.go
+++ b/usecases/cost_test.go
@@ -79,7 +79,7 @@ func TestSetActivitiesCost(t *testing.T) {
 			"timestamp":"0001-01-01T00:00:00Z","version":"WrongVersion"}`,
 			true, "Bad case, unsupported version",
 		},
-		// Bad case: mismatch between 'serv.Definition' and 'acForm.Activity'
+		// Bad case: Mismatch between 'serv.Definition' and 'acForm.Activity'
 		{
 			`{"activity":"WrongDef","cost":321,"unit":"",
 			"timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`,
@@ -91,6 +91,12 @@ func TestSetActivitiesCost(t *testing.T) {
 			"timestamp":"0001-01-01T00:00:00Z","version":"ActivityCostForm_v1"}`,
 			true, "Bad case, break first unmarshal",
 		},
+		// Bad case: Couldn't convert to ActivityCostForm_v1
+		{
+			`{"file_url":"filepath",
+			"timestamp":"0001-01-01T00:00:00Z","version":"FileForm_v1"}`,
+			true, "Bad case, couldn't convert to ActivityCostForm_v1",
+		},
 	}
 	testServ := createTestService()
 

From fc702b4750ab76357ec5bbe17416719fa780c268 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Mon, 7 Jul 2025 12:54:39 +0200
Subject: [PATCH 138/186] Added comment explaining the use of (*ua)

---
 usecases/cost.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/usecases/cost.go b/usecases/cost.go
index c47c239..865c5d5 100644
--- a/usecases/cost.go
+++ b/usecases/cost.go
@@ -60,6 +60,7 @@ func SetActivitiesCost(serv *components.Service, bodyBytes []byte) (err error) {
 
 // ACServices handles the http request for the cost of a service
 func ACServices(w http.ResponseWriter, r *http.Request, ua *components.UnitAsset, serviceP string) {
+	// Has to use (*ua) in order to reach the methods for the interface UnitAsset, since ua is a pointer to an interface
 	servicesList := (*ua).GetServices()
 	serv := servicesList[serviceP]
 	switch r.Method {

From 8a712fa56b15f8aff9e069fab764ce5be8bc4bfb Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sat, 5 Jul 2025 14:30:33 +0200
Subject: [PATCH 139/186] Adds govulncheck scanner

---
 Makefile | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Makefile b/Makefile
index 87d4a27..ddbd2d1 100644
--- a/Makefile
+++ b/Makefile
@@ -8,6 +8,7 @@ lint:
 	go vet $$(go list ./... | grep -v /tmp)
 	gosec -quiet -fmt=golint -exclude-dir="tmp" ./...
 	staticcheck ./...
+	govulncheck -test ./...
 	# pointerinterface ./...
 
 # Runs spellchecker on the code and comments
@@ -33,6 +34,7 @@ installpkgs:
 	go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
 	go install github.com/securego/gosec/v2/cmd/gosec@latest
 	go install honnef.co/go/tools/cmd/staticcheck@latest
+	go install golang.org/x/vuln/cmd/govulncheck@latest
 	# go install code.larus.se/lmas/pointerinterface@latest
 
 # Clean up built binary and other temporary files (ignores errors from rm)

From 93cef25f2a0d8698b1250d8e66bc47d0f2941bba Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sat, 5 Jul 2025 14:30:33 +0200
Subject: [PATCH 140/186] Upgrades module version and fixes linter warnings

---
 go.mod                | 2 +-
 usecases/utilities.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/go.mod b/go.mod
index 1b71a59..f0890bb 100644
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,3 @@
 module github.com/sdoque/mbaigo
 
-go 1.23.4
+go 1.24.4
diff --git a/usecases/utilities.go b/usecases/utilities.go
index 535174a..361d8eb 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -94,7 +94,7 @@ func Unpack(data []byte, contentType string) (forms.Form, error) {
 	// Look up the form type in the map
 	formType, exists := forms.FormTypeMap[formVersion]
 	if !exists {
-		return nil, fmt.Errorf("unsupported form version: " + formVersion)
+		return nil, fmt.Errorf("unsupported form version: %s", formVersion)
 	}
 
 	// Create a new instance of the form

From a9116561c16943f12d943000f63dd765c6d72406 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Tue, 8 Jul 2025 14:47:26 +0200
Subject: [PATCH 141/186] Adds new system message form for the new messenger
 system

---
 forms/message_forms.go | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 forms/message_forms.go

diff --git a/forms/message_forms.go b/forms/message_forms.go
new file mode 100644
index 0000000..7323170
--- /dev/null
+++ b/forms/message_forms.go
@@ -0,0 +1,39 @@
+package forms
+
+// MessageLevel indicates the importance or criticality of a message.
+type MessageLevel int
+
+// Mimics the levels from the "slog" package
+const (
+	LevelDebug MessageLevel = -4
+	LevelInfo  MessageLevel = 0
+	LevelWarn  MessageLevel = 4
+	LevelError MessageLevel = 8
+)
+
+// A SystemMessage is a log message sent from a system to one or many messengers.
+// The receiving messengers will note the message's time of arrival.
+type SystemMessage_v1 struct {
+	Level   MessageLevel `json:"level"`
+	Body    string       `json:"body"`
+	System  string       `json:"system"`
+	Version string       `json:"version"`
+}
+
+func NewSystemMessage_v1(l MessageLevel, b string, s string) Form {
+	return &SystemMessage_v1{
+		Level:   l,
+		Body:    b,
+		System:  s,
+		Version: "SystemMessage_v1",
+	}
+}
+
+// NewForm resets the form and defaults to LevelInfo.
+//
+// Note: Unnecessary to use pointers but must match the other forms
+func (f *SystemMessage_v1) NewForm() Form {
+	return NewSystemMessage_v1(LevelInfo, "", "")
+}
+
+func (f *SystemMessage_v1) FormVersion() string { return f.Version }

From 7ce238a66a002b7b080f7bee33811d9b476cb60a Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 9 Jul 2025 09:22:51 +0200
Subject: [PATCH 142/186] Moves sendHttpReq to utilities file

---
 usecases/consumption.go            |  2 +-
 usecases/service_discovery.go      | 21 ++-------------------
 usecases/service_discovery_test.go |  2 +-
 usecases/utilities.go              | 17 +++++++++++++++++
 4 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index 8f5ac96..edf1e59 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -55,7 +55,7 @@ func stateHandler(httpMethod string, cer *components.Cervice, sys *components.Sy
 		}
 	}
 
-	resp, err := sendHttpReq(httpMethod, serviceUrl, bodyBytes)
+	resp, err := sendHTTPReq(httpMethod, serviceUrl, bodyBytes)
 	if err != nil {
 		cer.Nodes = make(map[string][]string) // Failed to get the resource at that location: reset the providers list, which will trigger a new service search
 		return f, err
diff --git a/usecases/service_discovery.go b/usecases/service_discovery.go
index 701f579..cc5e00f 100644
--- a/usecases/service_discovery.go
+++ b/usecases/service_discovery.go
@@ -20,7 +20,6 @@
 package usecases
 
 import (
-	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -75,22 +74,6 @@ func ExtractQuestForm(bodyBytes []byte) (rec forms.ServiceQuest_v1, err error) {
 	return
 }
 
-func sendHttpReq(method string, url string, data []byte) (resp *http.Response, err error) {
-	req, err := http.NewRequest(method, url, bytes.NewBuffer(data))
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Content-Type", "application/json") // set the Content-Type header
-	resp, err = http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return nil, fmt.Errorf("bad response: %d %s", resp.StatusCode, resp.Status)
-	}
-	return
-}
-
 // Search4Service requests from the core systems the address of resources's services that meet the need
 func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocation forms.ServicePoint_v1, err error) {
 	// Create a new HTTP request to the Orchestrator system (for now the Service Registrar)
@@ -104,7 +87,7 @@ func Search4Service(qf forms.ServiceQuest_v1, sys *components.System) (servLocat
 	if err != nil {
 		return
 	}
-	resp, err := sendHttpReq(http.MethodPost, orURL, jsonQF)
+	resp, err := sendHTTPReq(http.MethodPost, orURL, jsonQF)
 	if err != nil {
 		return
 	}
@@ -143,7 +126,7 @@ func Search4Services(cer *components.Cervice, sys *components.System) (err error
 	}
 	orURL = orURL + "/squest"
 	// Prepare the request to the orchestrator
-	resp, err := sendHttpReq(http.MethodPost, orURL, qf)
+	resp, err := sendHTTPReq(http.MethodPost, orURL, qf)
 	if err != nil {
 		return err
 	}
diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index 332f28c..af14275 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -199,7 +199,7 @@ func TestSendHttpReq(t *testing.T) {
 			lastLoopErr = true
 		}
 		// Run the test
-		_, err = sendHttpReq(c.method, c.url, c.data)
+		_, err = sendHTTPReq(c.method, c.url, c.data)
 		if c.expectError == false {
 			if err != nil {
 				t.Errorf("Unexpected error in '%s' test case: %e", c.testCase, err)
diff --git a/usecases/utilities.go b/usecases/utilities.go
index 361d8eb..b073cde 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -24,6 +24,7 @@ import (
 	"encoding/json"
 	"encoding/xml"
 	"fmt"
+	"net/http"
 	"reflect"
 	"strings"
 	"unicode"
@@ -162,3 +163,19 @@ func IsPascalCase(s string) bool {
 func IsCamelCase(s string) bool {
 	return IsFirstLetterLower(s)
 }
+
+func sendHTTPReq(method string, url string, data []byte) (resp *http.Response, err error) {
+	req, err := http.NewRequest(method, url, bytes.NewBuffer(data))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, fmt.Errorf("bad response: %d %s", resp.StatusCode, resp.Status)
+	}
+	return
+}

From 0ee16d044af8af0c0fbee9d96c1de08f40b02b96 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 9 Jul 2025 09:22:51 +0200
Subject: [PATCH 143/186] Adds messenger registration form

---
 forms/message_forms.go | 50 ++++++++++++++++++++++++++++++++++++------
 1 file changed, 43 insertions(+), 7 deletions(-)

diff --git a/forms/message_forms.go b/forms/message_forms.go
index 7323170..db0cc26 100644
--- a/forms/message_forms.go
+++ b/forms/message_forms.go
@@ -1,5 +1,40 @@
 package forms
 
+import (
+	"reflect"
+)
+
+// Register the forms
+func init() {
+	FormTypeMap[messengerRegistrationVersion] = reflect.TypeOf(MessengerRegistration_v1{})
+	FormTypeMap[systemMessageVersion] = reflect.TypeOf(SystemMessage_v1{})
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+type MessengerRegistration_v1 struct {
+	Host    string `json:"host"`
+	Version string `json:"version"`
+}
+
+const messengerRegistrationVersion string = "MessengerRegistration_v1"
+
+func NewMessengerRegistration_v1(host string) MessengerRegistration_v1 {
+	return MessengerRegistration_v1{
+		Host:    host,
+		Version: messengerRegistrationVersion,
+	}
+}
+
+func (f *MessengerRegistration_v1) NewForm() Form {
+	new := NewMessengerRegistration_v1("")
+	return &new
+}
+
+func (f *MessengerRegistration_v1) FormVersion() string { return f.Version }
+
+////////////////////////////////////////////////////////////////////////////////
+
 // MessageLevel indicates the importance or criticality of a message.
 type MessageLevel int
 
@@ -20,20 +55,21 @@ type SystemMessage_v1 struct {
 	Version string       `json:"version"`
 }
 
-func NewSystemMessage_v1(l MessageLevel, b string, s string) Form {
-	return &SystemMessage_v1{
+const systemMessageVersion string = "SystemMessage_v1"
+
+func NewSystemMessage_v1(l MessageLevel, b string, s string) SystemMessage_v1 {
+	return SystemMessage_v1{
 		Level:   l,
 		Body:    b,
 		System:  s,
-		Version: "SystemMessage_v1",
+		Version: systemMessageVersion,
 	}
 }
 
-// NewForm resets the form and defaults to LevelInfo.
-//
-// Note: Unnecessary to use pointers but must match the other forms
+// NewForm resets the form and defaults to using LevelInfo.
 func (f *SystemMessage_v1) NewForm() Form {
-	return NewSystemMessage_v1(LevelInfo, "", "")
+	new := NewSystemMessage_v1(LevelInfo, "", "")
+	return &new
 }
 
 func (f *SystemMessage_v1) FormVersion() string { return f.Version }

From 5f0d0e30a9ae10b87cb1758316655791b64a8b93 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 9 Jul 2025 09:22:51 +0200
Subject: [PATCH 144/186] Adds messenger registration endpoint to systems

---
 components/system.go         |  2 ++
 usecases/provision.go        | 25 +++++++++++++++++++++++++
 usecases/servers_handlers.go |  2 ++
 3 files changed, 29 insertions(+)

diff --git a/components/system.go b/components/system.go
index 6251ca4..c65a60a 100644
--- a/components/system.go
+++ b/components/system.go
@@ -30,6 +30,7 @@ import (
 	"net/url"
 	"os"
 	"os/signal"
+	"sync"
 	"syscall"
 )
 
@@ -43,6 +44,7 @@ type System struct {
 	Ctx           context.Context       // create a context that can be cancelled
 	Sigs          chan os.Signal        // channel to initiate a graceful shutdown when Ctrl+C is pressed
 	RegistrarChan chan *CoreSystem      // channel for the lead service registrar
+	Messengers    sync.Map              // Tracks which hosts to send log msgs to (and how many errors were encountered, before being removed)
 }
 
 // CoreSystem struct holds details about the core system included in the configuration file
diff --git a/usecases/provision.go b/usecases/provision.go
index 12ee15a..7dd582b 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -26,6 +26,7 @@ import (
 	"net/http"
 	"strings"
 
+	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
 )
 
@@ -121,3 +122,27 @@ func getBestContentType(acceptHeader string) string {
 
 	return bestType
 }
+
+func RegisterMessenger(w http.ResponseWriter, r *http.Request, s *components.System) {
+	b, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Printf("read request body: %v\n", err)
+		http.Error(w, http.StatusText(http.StatusInternalServerError),
+			http.StatusInternalServerError)
+		return
+	}
+	defer r.Body.Close()
+	f, err := Unpack(b, r.Header.Get("Content-Type"))
+	if err != nil {
+		log.Printf("unpack: %v\n", err)
+		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+		return
+	}
+	reg, ok := f.(*forms.MessengerRegistration_v1)
+	if !ok {
+		log.Println("form is not a MessengerRegistration_v1")
+		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+		return
+	}
+	s.Messengers.Store(reg.Host, 0) // Registers the host with 0 errors
+}
diff --git a/usecases/servers_handlers.go b/usecases/servers_handlers.go
index 6fb74c8..13e557b 100644
--- a/usecases/servers_handlers.go
+++ b/usecases/servers_handlers.go
@@ -206,6 +206,8 @@ func handleThreeParts(w http.ResponseWriter, r *http.Request, part string, sys *
 		KGraphing(w, r, sys)
 	case "cert":
 		forms.Certificate(w, r, *sys)
+	case "msg":
+		RegisterMessenger(w, r, sys)
 	default:
 		http.Error(w, "Invalid request", http.StatusBadRequest)
 	}

From bee3f89e00c924767788a24ab01df4799d7aa1eb Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Sat, 5 Jul 2025 16:24:48 +0200
Subject: [PATCH 145/186] Refactored registration and add extra error return

---
 usecases/registration.go      | 87 +++++++++++++++++------------------
 usecases/registration_test.go | 21 +++++----
 2 files changed, 53 insertions(+), 55 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index cb7bf23..5a4c725 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -23,9 +23,9 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
 	"log"
-	"net"
 	"net/http"
 	"strconv"
 	"sync"
@@ -83,12 +83,16 @@ func RegisterServices(sys *components.System) {
 		for _, service := range servs {
 			go func(theUnitAsset *components.UnitAsset, theService *components.Service) {
 				delay := 1 * time.Second
+				var err error
 				for {
 					select {
 					case <-time.Tick(delay):
-						delay = registerService(sys, registrar.get(), theUnitAsset, theService)
+						delay, err = registerService(sys, registrar.get(), theUnitAsset, theService)
+						if err != nil {
+							log.Println("registering service:", err)
+						}
 					case <-sys.Ctx.Done():
-						err := unregisterService(registrar.get(), theService)
+						err = unregisterService(registrar.get(), theService)
 						if err != nil {
 							log.Println("unregistering service:", err)
 						}
@@ -101,16 +105,16 @@ func RegisterServices(sys *components.System) {
 }
 
 // registerService makes a POST or PUT request to register or register individual services
-func registerService(sys *components.System, registrar string, ua *components.UnitAsset, serv *components.Service) (delay time.Duration) {
+func registerService(sys *components.System, registrar string, ua *components.UnitAsset, serv *components.Service) (delay time.Duration, err error) {
 	delay = 15 * time.Second
 	if registrar == "" {
-		return delay
+		return
 	}
 
 	// Prepare request
 	reqPayload, err := serviceRegistrationForm(sys, ua, serv, "ServiceRecord_v1")
 	if err != nil {
-		log.Println("Registration marshall error, ", err)
+		err = fmt.Errorf("registration marshall: %w", err)
 		return
 	}
 	registrationURL := registrar + "/register"
@@ -119,13 +123,13 @@ func registerService(sys *components.System, registrar string, ua *components.Un
 	if serv.ID == 0 {
 		req, err = http.NewRequest("POST", registrationURL, bytes.NewBuffer(reqPayload))
 		if err != nil {
-			log.Printf("unable to register service %s with lead registrar\n", serv.Definition)
+			err = fmt.Errorf("unable to register service %s with lead registrar", serv.Definition)
 			return
 		}
 	} else {
 		req, err = http.NewRequest("PUT", registrationURL, bytes.NewBuffer(reqPayload))
 		if err != nil {
-			log.Printf("unable to confirm the %s service with lead registrar", serv.Definition)
+			err = fmt.Errorf("unable to confirm the %s service with lead registrar", serv.Definition)
 			return
 		}
 	}
@@ -133,54 +137,45 @@ func registerService(sys *components.System, registrar string, ua *components.Un
 
 	resp, err := http.DefaultClient.Do(req) // execute the request and get the reply
 	if err != nil {
-		switch err := err.(type) {
-		case net.Error:
-			if err.Timeout() {
-				log.Printf("registry timeout with lead registrar %s\n", registrationURL)
-			} else {
-				log.Printf("unable to (re-)register service %s with lead registrar\n", serv.Definition)
-			}
-		default:
-			log.Printf("registration request error with %s, and error %s\n", registrationURL, err)
-		}
+		err = fmt.Errorf("registration request: %w", err)
 		serv.ID = 0 // if re-registration failed, a complete new one should be made (POST)
 		return
 	}
 
 	// Handle response ------------------------------------------------
 
-	if resp != nil {
-		defer resp.Body.Close()
-		bodyBytes, err := io.ReadAll(resp.Body) // Use io.ReadAll instead of ioutil.ReadAll
-		if err != nil {
-			log.Printf("Error reading registration response body: %v", err)
-			return
-		}
+	var b []byte
+	b, err = io.ReadAll(resp.Body) // Use io.ReadAll instead of ioutil.ReadAll
+	if err != nil {
+		err = fmt.Errorf("reading registration response body: %w", err)
+		return
+	}
+	defer resp.Body.Close()
 
-		headerContentType := resp.Header.Get("Content-Type")
-		rRecord, err := Unpack(bodyBytes, headerContentType)
-		if err != nil {
-			log.Printf("error extracting the registration record reply %v\n", err)
-		}
+	headerContentType := resp.Header.Get("Content-Type")
+	rRecord, err := Unpack(b, headerContentType)
+	if err != nil {
+		err = fmt.Errorf("extracting the registration record reply: %w", err)
+		return
+	}
 
-		// Perform a type assertion to convert the returned Form to ServiceRecord_v1
-		rr, ok := rRecord.(*forms.ServiceRecord_v1)
-		if !ok {
-			log.Println("Problem unpacking the service registration reply")
-			return
-		}
+	// Perform a type assertion to convert the returned Form to ServiceRecord_v1
+	rr, ok := rRecord.(*forms.ServiceRecord_v1)
+	if !ok {
+		err = fmt.Errorf("invalid form from the service registration reply")
+		return
+	}
 
-		serv.ID = rr.Id
-		serv.RegTimestamp = rr.Created
-		serv.RegExpiration = rr.EndOfValidity
-		parsedTime, err := time.Parse(time.RFC3339, rr.EndOfValidity)
-		if err != nil {
-			log.Printf("Error parsing input: %s", err)
-			return
-		}
-		// should not wait until the deadline to start to confirm live status
-		delay = time.Until(parsedTime.Add(-5 * time.Second))
+	serv.ID = rr.Id
+	serv.RegTimestamp = rr.Created
+	serv.RegExpiration = rr.EndOfValidity
+	parsedTime, err := time.Parse(time.RFC3339, rr.EndOfValidity)
+	if err != nil {
+		err = fmt.Errorf("parsing time: %w", err)
+		return
 	}
+	// should not wait until the deadline to start to confirm live status
+	delay = time.Until(parsedTime.Add(-5 * time.Second))
 	return
 }
 
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 894fd38..0f7772c 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -201,7 +201,10 @@ func TestRegisterService(t *testing.T) {
 
 	// Good case, everything works, service gets registered
 	newMockTransport(respFunc, 0, nil)
-	test := registerService(&testSys, registrar, mua, serv)
+	test, err := registerService(&testSys, registrar, mua, serv)
+	if err != nil {
+		t.Errorf("Expected no errors, got: %v", err)
+	}
 	if int(test.Seconds()) > 0 {
 		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
 	}
@@ -209,7 +212,7 @@ func TestRegisterService(t *testing.T) {
 	// Bad case: when NewRequest with PUT method fails
 	newMockTransport(respFunc, 0, nil)
 	registrar = brokenUrl
-	test = registerService(&testSys, registrar, mua, serv)
+	test, _ = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since NewRequest with PUT method should have failed, got: %d", int(test.Seconds()))
 	}
@@ -241,7 +244,7 @@ func TestRegisterService(t *testing.T) {
 
 	// Good case when making POST instead
 	newMockTransport(respFunc, 0, nil)
-	test = registerService(&testSys, registrar, mua, serv)
+	test, _ = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) > 0 {
 		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
 	}
@@ -249,7 +252,7 @@ func TestRegisterService(t *testing.T) {
 	// Bad case: when NewRequest with POST method fails
 	newMockTransport(respFunc, 0, nil)
 	registrar = brokenUrl
-	test = registerService(&testSys, registrar, mua, serv)
+	test, _ = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since NewRequest with POST method should have failed, got: %d", int(test.Seconds()))
 	}
@@ -258,14 +261,14 @@ func TestRegisterService(t *testing.T) {
 	// Bad case: when http.DefaultClient.Do() fails with a err.Timeout()
 	timeoutErr := timeoutError{}
 	newMockTransport(respFunc, 1, timeoutErr)
-	test = registerService(&testSys, registrar, mua, serv)
+	test, _ = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
 	}
 
 	// Bad case: when http.DefaultClient.Do() fails but not with a err.Timeout()
 	newMockTransport(respFunc, 1, errHTTP)
-	test = registerService(&testSys, registrar, mua, serv)
+	test, _ = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
 	}
@@ -281,7 +284,7 @@ func TestRegisterService(t *testing.T) {
 
 	// Bad case: when io.ReadAll() returns an error
 	newMockTransport(respFunc, 0, nil)
-	test = registerService(&testSys, registrar, mua, serv)
+	test, _ = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the io.ReadAll() call should fail, got %d", int(test.Seconds()))
 	}
@@ -297,7 +300,7 @@ func TestRegisterService(t *testing.T) {
 
 	// Bad case: when Unpack() fails because of a non-existent "Content-Type" in the Header of the response
 	newMockTransport(respFunc, 0, nil)
-	test = registerService(&testSys, registrar, mua, serv)
+	test, _ = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the Header had a non-existent/invalid Content-Type, got: %d", int(test.Seconds()))
 	}
@@ -318,7 +321,7 @@ func TestRegisterService(t *testing.T) {
 
 	// Bad case: Error parsing the EndOfValidity into the RFC3339 time format
 	newMockTransport(respFunc, 0, nil)
-	test = registerService(&testSys, registrar, mua, serv)
+	test, _ = registerService(&testSys, registrar, mua, serv)
 	if int(test.Seconds()) != 15 {
 		t.Errorf("Expected the delay to be 15 since the EndOfValidity has a faulty time format, got: %d", int(test.Seconds()))
 	}

From c20d68c1ec7e915218a2363ed22bbd2fc53e6e15 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Tue, 8 Jul 2025 14:43:19 +0200
Subject: [PATCH 146/186] Started refactoring tests for
 usecases/registration.go

---
 usecases/registration_test.go | 462 +++++++++++++++++-----------------
 1 file changed, 224 insertions(+), 238 deletions(-)

diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 0f7772c..8779fd8 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -4,12 +4,13 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
-	"reflect"
 	"strings"
 	"testing"
 	"time"
 
+	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
 )
 
@@ -25,90 +26,136 @@ func (errorReader) Read(p []byte) (int, error) {
 	return 0, fmt.Errorf("forced read error")
 }
 
-func TestDeepCopyMap(t *testing.T) {
-	testSys := createTestSystem(false)
-	mua := testSys.UAssets["testUnitAsset"]
-	original := (*mua).GetDetails()
-
-	// Create a Deep Copy Map of the mockUnitAsset's Details
-	test := deepCopyMap((*mua).GetDetails())
-	// If they are not equal from the beginning then the copy was not successful
-	if !reflect.DeepEqual(original, test) {
-		t.Errorf("Expected deep copied map to be equal to original, Expected: %v, got: %v", original, test)
+func manualEqualityCheck(map1 map[string][]string, map2 map[string][]string) error {
+	if len(map1) != len(map2) {
+		return fmt.Errorf("Expected map length %d, got %d", len(map2), len(map1))
 	}
-
-	// When we change something in the original, the deep copied map should not change
-	original["Test"][0] = "changed original"
-	if reflect.DeepEqual(original, test) {
-		t.Errorf("Deep copy failed, changes in original affected the deep copied map. Expected: %v, got %v", original, test)
+	for key, value := range map2 {
+		mv, ok := map1[key]
+		if !ok {
+			return fmt.Errorf("Expected key %q not found in merged map", key)
+		}
+		if len(mv) != len(value) {
+			return fmt.Errorf("For key %q, expected slice length %d, got %d", key, len(value), len(mv))
+		}
+		for i := range value {
+			if mv[i] != value[i] {
+				return fmt.Errorf("For key %q, at index %d, expected %q, got %q", key, i, value[i], mv[i])
+			}
+		}
 	}
-	original["Test"][0] = "test"
-
-	// When we change something in the deep copied map, the original should not change
-	test["Test"][0] = "changed deep copy"
-	if reflect.DeepEqual(original, test) {
-		t.Errorf("Deep copy failed, changes in deep copied map affected the original. Expected: %v, got %v", original, test)
+	for key := range map1 {
+		if _, ok := map2[key]; !ok {
+			return fmt.Errorf("Unexpected key %q found in merged map", key)
+		}
 	}
+	return nil
 }
 
-func TestServiceRegistrationForm(t *testing.T) {
-	testSys := createTestSystem(false)
-	mua := testSys.UAssets["testUnitAsset"]
-	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
-	version := "ServiceRecord_v1"
+type deepCopyMapTestStruct struct {
+	mockSystem components.System
+	testName   string
+}
 
-	// Call the ServiceRegistrationForm with the correct parameters
-	payload, err := serviceRegistrationForm(&testSys, mua, serv, version)
-	// Check that there was no error in the function (can only be when wrong Service Record version is sent in)
-	if err != nil {
-		t.Fatalf("The Service Record version was wrong.")
-	}
-	var sr forms.ServiceRecord_v1
-	if err = json.Unmarshal(payload, &sr); err != nil {
-		t.Fatalf("Invalid JSON: %v", err)
-	}
+var deepCopyMapTestParams = []deepCopyMapTestStruct{
+	{createTestSystem(false), "Good case, the copy works as a deep copy"},
+}
 
-	// Check that the ServiceNode is created correctly
-	expectedNode := testSys.Host.Name + "_" + testSys.Name + "_" +
-		(*testSys.UAssets["testUnitAsset"]).GetName() + "_" +
-		(*testSys.UAssets["testUnitAsset"]).GetServices()["test"].Definition
-	if sr.ServiceNode != expectedNode {
-		t.Errorf("Expected ServiceNode %q, got: %q", expectedNode, sr.ServiceNode)
-	}
+func TestDeepCopyMap(t *testing.T) {
+	for _, testCase := range deepCopyMapTestParams {
+		mua := testCase.mockSystem.UAssets["testUnitAsset"]
+		original := (*mua).GetDetails()
 
-	// Check that the ProtoPorts that are equal to 0 gets removed
-	if len(sr.ProtoPort) != 1 {
-		t.Errorf("Expected: one proto port (excluding 0s), got: %v", sr.ProtoPort)
-	}
+		test := deepCopyMap((*mua).GetDetails())
 
-	// Check that the unit asset details exists and are ok
-	if v, ok := sr.Details["Test"]; !ok || len(v) != 1 {
-		t.Errorf("Missing or incorrect unit asset details. Expected: %v, got: %v", (*mua).GetDetails(), v)
-	}
+		// If they are not equal from the beginning then the copy was not successful
+		err := manualEqualityCheck(original, test)
+		if err != nil {
+			t.Errorf("In test case: %s: Expected deep copied map to be equal to original, Expected: %v, got: %v", testCase.testName, original, test)
+		}
 
-	// Check that the service forms exists and are ok
-	if v, ok := sr.Details["Forms"]; !ok || len(v) != 1 {
-		t.Errorf("Missing or incorrect service forms. Expected: %v, got: %v", (*serv).Details, v)
-	}
+		// When we change something in the original, the deep copied map should not change
+		original["Test"][0] = "changed original"
+		err = manualEqualityCheck(original, test)
+		if err == nil {
+			t.Errorf("In test case: %s: Deep copy failed, changes in original affected the deep copied map. Expected: %v, got %v", testCase.testName, original, test)
+		}
+		original["Test"][0] = "test"
 
-	// Bad case: Sent in version is not supported
-	version = "UnknownVersion"
-	_, err = serviceRegistrationForm(&testSys, mua, serv, version)
-	if err == nil {
-		t.Fatal("expected error for unsupported version, got nil")
+		// When we change something in the deep copied map, the original should not change
+		test["Test"][0] = "changed deep copy"
+		err = manualEqualityCheck(original, test)
+		if err == nil {
+			t.Errorf("In test case: %s: Deep copy failed, changes in deep copied map affected the original. Expected: %v, got %v", testCase.testName, original, test)
+		}
 	}
-	if err.Error() != "unsupported service registration form version" {
-		t.Errorf("Expected error: unsupported service registration form version, got: %v", err)
+}
+
+type serviceRegistrationFormTestStruct struct {
+	version     string
+	expectedErr bool
+	testName    string
+}
+
+var serviceRegistrationFormTestParams = []serviceRegistrationFormTestStruct{
+	{"ServiceRecord_v1", false, "Good case, everything works"},
+	{"Wrong version", true, "Bad case, the wrong version string is sent in"},
+}
+
+func TestServiceRegistrationForm(t *testing.T) {
+	for _, testCase := range serviceRegistrationFormTestParams {
+		testSys := createTestSystem(false)
+		mua := testSys.UAssets["testUnitAsset"]
+		serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
+
+		payload, err := serviceRegistrationForm(&testSys, mua, serv, testCase.version)
+		if (testCase.expectedErr == true && err == nil) || (testCase.expectedErr == false && err != nil) {
+			t.Errorf("In test case: %s: Expected %t error, got: %v", testCase.testName, testCase.expectedErr, err)
+		}
+
+		if testCase.expectedErr == false {
+			var sr forms.ServiceRecord_v1
+			if err = json.Unmarshal(payload, &sr); err != nil {
+				t.Fatalf("Invalid JSON: %v", err)
+			}
+
+			// Check that the ServiceNode is created correctly
+			expectedNode := testSys.Host.Name + "_" + testSys.Name + "_" +
+				(*testSys.UAssets["testUnitAsset"]).GetName() + "_" +
+				(*testSys.UAssets["testUnitAsset"]).GetServices()["test"].Definition
+			if sr.ServiceNode != expectedNode {
+				t.Errorf("Expected ServiceNode %q, got: %q", expectedNode, sr.ServiceNode)
+			}
+
+			// Check that the ProtoPorts that are equal to 0 gets removed
+			if len(sr.ProtoPort) != 1 {
+				t.Errorf("Expected: one proto port (excluding 0s), got: %v", sr.ProtoPort)
+			}
+
+			// Check that the unit asset details exists and are ok
+			if v, ok := sr.Details["Test"]; !ok || len(v) != 1 {
+				t.Errorf("Missing or incorrect unit asset details. Expected: %v, got: %v", (*mua).GetDetails(), v)
+			}
+
+			// Check that the service forms exists and are ok
+			if v, ok := sr.Details["Forms"]; !ok || len(v) != 1 {
+				t.Errorf("Missing or incorrect service forms. Expected: %v, got: %v", (*serv).Details, v)
+			}
+		}
 	}
 
+	// Special case
 	// Check that when the Service RegPeriod equals 0, ServiceRegistrationForm defaults to its RegLife default value of 30
+	testSys := createTestSystem(false)
+	mua := testSys.UAssets["testUnitAsset"]
+	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
 	(*testSys.UAssets["testUnitAsset"]).GetServices()["test"].RegPeriod = 0
-	version = "ServiceRecord_v1"
-	payload, err = serviceRegistrationForm(&testSys, mua, serv, version)
+	version := "ServiceRecord_v1"
+	payload, err := serviceRegistrationForm(&testSys, mua, serv, version)
 	if err != nil {
 		t.Fatalf("The Service Record version was wrong.")
 	}
-
+	var sr forms.ServiceRecord_v1
 	if err := json.Unmarshal(payload, &sr); err != nil {
 		t.Fatalf("Invalid JSON: %v", err)
 	}
@@ -117,44 +164,32 @@ func TestServiceRegistrationForm(t *testing.T) {
 	}
 }
 
-func TestUnregisterService(t *testing.T) {
-	testSys := createTestSystem(false)
-	registrar := testSys.CoreS[0].Url
-	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
-	respFunc := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Body:       io.NopCloser(strings.NewReader(string("test body"))),
-		}
-	}
-
-	// Good case: No errors when a service not registered tries to get deregistered
-	newMockTransport(respFunc, 0, nil)
-	err := unregisterService(registrar, serv)
-	if err != nil {
-		t.Errorf("Expected error: %v, got: %v", nil, err)
-	}
-
-	// Good case: No errors when a service registered tries to get deregistered
-	err = unregisterService(registrar, serv)
-	if err != nil {
-		t.Errorf("Expected error: %v, got: %v", nil, err)
-	}
+type unregisterServiceTestStruct struct {
+	registrarUrl     string
+	expectedErr      bool
+	mockTransportErr int
+	errHTTP          error
+	testName         string
+}
 
-	// bad case: response body error
-	newMockTransport(respFunc, 1, errHTTP)
-	err = unregisterService(registrar, serv)
-	if err == nil {
-		t.Errorf("Expected error while sending http request")
-	}
+var unregisterServiceTestParams = []unregisterServiceTestStruct{
+	{"https://leadingregistrar", false, 0, nil, "Good case, an unregistered service tries to unregister"},
+	{"https://leadingregistrar", false, 0, nil, "Good case, an registered service tries to unregister"},
+	{"https://leadingregistrar", true, 1, errHTTP, "Bad case, error in response body"},
+	{"", false, 0, nil, "Good case, no leading registrar URL was sent in"},
+	{brokenUrl, true, 0, nil, "Bad case, broken URL"},
+}
 
-	// bad case: URL broken
-	newMockTransport(respFunc, 0, nil)
-	registrar = brokenUrl
-	err = unregisterService(registrar, serv)
-	if err == nil {
-		t.Errorf("Expected error while creating http request")
+func TestUnregisterService(t *testing.T) {
+	for _, testCase := range unregisterServiceTestParams {
+		testSys := createTestSystem(false)
+		serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
+
+		newMockTransport(createWorkingHttpResp(), testCase.mockTransportErr, testCase.errHTTP)
+		err := unregisterService(testCase.registrarUrl, serv)
+		if (testCase.expectedErr == true && err == nil) || (testCase.expectedErr == false && err != nil) {
+			t.Errorf("In test case: %s: We expected %t error, got: %v", testCase.testName, testCase.expectedErr, err)
+		}
 	}
 }
 
@@ -164,165 +199,116 @@ func TestServiceRegistrationFormList(t *testing.T) {
 	}
 	// Check that the return value of ServiceRegistrationFormsList is equal to the expected list of ServiceRegistrationForms
 	test := ServiceRegistrationFormsList()
-	if !reflect.DeepEqual(list, test) {
-		t.Errorf("Expected lists to be equal. Expected: %v, got: %v", list, test)
+	for i := range list {
+		if list[i] != test[i] {
+			t.Errorf("Expected lists to be equal. Expected: %v, got: %v", list, test)
+			break
+		}
 	}
 }
 
-func TestRegisterService(t *testing.T) {
-	testSys := createTestSystem(false)
-	registrar := testSys.CoreS[0].Url
-	mua := testSys.UAssets["testUnitAsset"]
-	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
+type registerServiceTestStruct struct {
+	registrarUrl     string
+	contentType      string
+	mockServID       int
+	correctTime      bool
+	brokenBody       bool
+	expectedErr      bool
+	mockTransportErr int
+	errHTTP          error
+	testName         string
+}
 
+func createWorkingRegisterServiceBody(mua *components.UnitAsset, serv *components.Service, correctTime bool, contentType string, brokenBody bool) func() *http.Response {
 	payload, err := serviceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
 	if err != nil {
-		t.Fatalf("The Service Record version was wrong.")
+		log.Fatalf("The service Record version was wrong")
 	}
 	var sr forms.ServiceRecord_v1
 	if err = json.Unmarshal(payload, &sr); err != nil {
-		t.Fatalf("Invalid JSON: %v", err)
-	}
-
-	sr.EndOfValidity = time.Now().Format(time.RFC3339)
-	fakeBody, err := json.Marshal(sr)
-	if err != nil {
-		t.Errorf("Fail Marshal at start of test")
-	}
-
-	respFunc := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
-		}
+		log.Fatalf("Invalid JSON: %v", err)
 	}
-
-	// Good case, everything works, service gets registered
-	newMockTransport(respFunc, 0, nil)
-	test, err := registerService(&testSys, registrar, mua, serv)
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-	if int(test.Seconds()) > 0 {
-		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
-	}
-
-	// Bad case: when NewRequest with PUT method fails
-	newMockTransport(respFunc, 0, nil)
-	registrar = brokenUrl
-	test, _ = registerService(&testSys, registrar, mua, serv)
-	if int(test.Seconds()) != 15 {
-		t.Errorf("Expected the delay to be 15 since NewRequest with PUT method should have failed, got: %d", int(test.Seconds()))
+	if correctTime == true {
+		sr.EndOfValidity = time.Now().Format(time.RFC3339)
+	} else {
+		sr.EndOfValidity = ""
 	}
-	registrar = testSys.CoreS[0].Url
-	serv.ID = 0
 
-	payload, err = serviceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
+	fakebody, err := json.Marshal(sr)
 	if err != nil {
-		t.Fatalf("The Service Record version was wrong.")
+		log.Fatalf("Fail marshal at start of test: %v", err)
 	}
 
-	if err = json.Unmarshal(payload, &sr); err != nil {
-		t.Fatalf("Invalid JSON: %v", err)
-	}
-
-	sr.EndOfValidity = time.Now().Format(time.RFC3339)
-	fakeBody, err = json.Marshal(sr)
-	if err != nil {
-		t.Errorf("Fail Marshal at start of test")
-	}
-	respFunc = func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+	if brokenBody == false {
+		respFunc := func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{contentType}},
+				Body:       io.NopCloser(strings.NewReader(string(fakebody))),
+			}
 		}
-	}
-
-	// Good case when making POST instead
-	newMockTransport(respFunc, 0, nil)
-	test, _ = registerService(&testSys, registrar, mua, serv)
-	if int(test.Seconds()) > 0 {
-		t.Errorf("Expected the delay to be negative, got: %d", int(test.Seconds()))
-	}
-
-	// Bad case: when NewRequest with POST method fails
-	newMockTransport(respFunc, 0, nil)
-	registrar = brokenUrl
-	test, _ = registerService(&testSys, registrar, mua, serv)
-	if int(test.Seconds()) != 15 {
-		t.Errorf("Expected the delay to be 15 since NewRequest with POST method should have failed, got: %d", int(test.Seconds()))
-	}
-	registrar = testSys.CoreS[0].Url
-
-	// Bad case: when http.DefaultClient.Do() fails with a err.Timeout()
-	timeoutErr := timeoutError{}
-	newMockTransport(respFunc, 1, timeoutErr)
-	test, _ = registerService(&testSys, registrar, mua, serv)
-	if int(test.Seconds()) != 15 {
-		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
-	}
-
-	// Bad case: when http.DefaultClient.Do() fails but not with a err.Timeout()
-	newMockTransport(respFunc, 1, errHTTP)
-	test, _ = registerService(&testSys, registrar, mua, serv)
-	if int(test.Seconds()) != 15 {
-		t.Errorf("Expected the delay to be 15 since the executed request should fail, got %d", int(test.Seconds()))
-	}
-
-	respFunc = func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(errorReader{}),
+		return respFunc
+	} else {
+		respFunc := func() *http.Response {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{contentType}},
+				Body:       io.NopCloser(errorReader{}),
+			}
 		}
+		return respFunc
 	}
+}
 
-	// Bad case: when io.ReadAll() returns an error
-	newMockTransport(respFunc, 0, nil)
-	test, _ = registerService(&testSys, registrar, mua, serv)
-	if int(test.Seconds()) != 15 {
-		t.Errorf("Expected the delay to be 15 since the io.ReadAll() call should fail, got %d", int(test.Seconds()))
-	}
+func createMockSysMockUnitAssetandMockService(id int) (mockSys components.System, mua *components.UnitAsset, mockServ *components.Service) {
+	mockSys = createTestSystem(false)
+	mua = mockSys.UAssets["testUnitAsset"]
+	mockServ = (*mockSys.UAssets["testUnitAsset"]).GetServices()["test"]
+	mockServ.ID = id
+	return
+}
 
-	respFunc = func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{}},
-			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
-		}
-	}
+var registerServiceTestParams = []registerServiceTestStruct{
+	{"https://leadingregistrar", "application/json", 1, true, false, false, 0, nil, "Good case, with PUT method"},
+	{"https://leadingregistrar", "application/json", 0, true, false, false, 0, nil, "Good case, with POST method"},
+	{"https://leadingregistrar", "application/json", 1, true, false, true, 1, timeoutError{}, "Bad case, timeout error"},
+	{"https://leadingregistrar", "application/json", 1, true, false, true, 1, errHTTP, "Bad case, error in defaultClint"},
+	{"https://leadingregistrar", "application/json", 1, true, true, true, 0, nil, "Bad case, error in ReadAll"},
+	{"https://leadingregistrar", "", 1, true, false, true, 0, nil, "Bad case, error in Unpack"},
+	{"https://leadingregistrar", "application/json", 1, false, false, true, 0, nil, "Bad case, error parsing time"},
+	{"", "application/json", 1, true, false, false, 0, nil, "Good case, no leading registrar URL sent in"},
+	{brokenUrl, "application/json", 1, true, false, true, 0, nil, "Bad case, broken URL with PUT method"},
+	{brokenUrl, "application/json", 0, true, false, true, 0, nil, "Bad case, broken URL with POST method"},
+}
 
-	// Bad case: when Unpack() fails because of a non-existent "Content-Type" in the Header of the response
-	newMockTransport(respFunc, 0, nil)
-	test, _ = registerService(&testSys, registrar, mua, serv)
-	if int(test.Seconds()) != 15 {
-		t.Errorf("Expected the delay to be 15 since the Header had a non-existent/invalid Content-Type, got: %d", int(test.Seconds()))
-	}
+var delay = time.Duration(15) * time.Second
 
-	sr.EndOfValidity = ""
-	fakeBody, err = json.Marshal(sr)
-	if err != nil {
-		t.Errorf("Fail Marshal at start of test")
-	}
-	respFunc = func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+func TestRegisterService(t *testing.T) {
+	for _, testCase := range registerServiceTestParams {
+		mockSys, mua, mockServ := createMockSysMockUnitAssetandMockService(testCase.mockServID)
+		respFunc := createWorkingRegisterServiceBody(mua, mockServ, testCase.correctTime, testCase.contentType, testCase.brokenBody)
+		newMockTransport(respFunc, testCase.mockTransportErr, testCase.errHTTP)
+
+		test, err := registerService(&mockSys, testCase.registrarUrl, mua, mockServ)
+
+		// Special case
+		if testCase.registrarUrl == "" {
+			if err != nil || test != delay {
+				t.Errorf("In test case: %s: Did we expect error? %t, got: %v and %d delay.", testCase.testName, testCase.expectedErr, err, test)
+			}
+			continue
 		}
-	}
 
-	// Bad case: Error parsing the EndOfValidity into the RFC3339 time format
-	newMockTransport(respFunc, 0, nil)
-	test, _ = registerService(&testSys, registrar, mua, serv)
-	if int(test.Seconds()) != 15 {
-		t.Errorf("Expected the delay to be 15 since the EndOfValidity has a faulty time format, got: %d", int(test.Seconds()))
+		if testCase.expectedErr == false {
+			if err != nil || test == delay {
+				t.Errorf("In test case: %s: Did we expect error? %t, got: %v and %d delay.", testCase.testName, testCase.expectedErr, err, test)
+			}
+		} else {
+			if err == nil || test != delay {
+				t.Errorf("In test case: %s: Did we expect error? %t, got: %v and %d delay.", testCase.testName, testCase.expectedErr, err, test)
+			}
+		}
 	}
 }

From ab88d5a3fbde283a5c0033ebbdfd1dabb35ad69a Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Wed, 9 Jul 2025 11:04:43 +0200
Subject: [PATCH 147/186] Refactored old tests to be table driven and cleaned
 up some code

---
 components/service_test.go    |  3 +-
 forms/file_forms_test.go      | 25 +++++----
 usecases/consumption_test.go  | 95 ++++++++++++++++++++++-------------
 usecases/provision_test.go    | 39 +++++++++-----
 usecases/registration_test.go | 66 ++++++++++++++++--------
 5 files changed, 147 insertions(+), 81 deletions(-)

diff --git a/components/service_test.go b/components/service_test.go
index 1984b4e..f7c054c 100644
--- a/components/service_test.go
+++ b/components/service_test.go
@@ -129,7 +129,8 @@ func TestMerge(t *testing.T) {
 	if testService.Definition != testOriginalService.Definition ||
 		testService.SubPath != testOriginalService.SubPath ||
 		testService.Description != testOriginalService.Description {
-		t.Errorf("Expected the test service to be the same as the original test service %s, got: %s", testOriginalService.Definition, testService.Definition)
+		t.Errorf("Expected the test service to be the same as the original test service %s, got: %s",
+			testOriginalService.Definition, testService.Definition)
 	}
 }
 
diff --git a/forms/file_forms_test.go b/forms/file_forms_test.go
index afe7b06..df763b6 100644
--- a/forms/file_forms_test.go
+++ b/forms/file_forms_test.go
@@ -37,20 +37,26 @@ func (e *mockResponseWriter) Header() http.Header {
 }
 
 var transferFileTestParams = []transferFileTestStruct{
-	{"test.jpeg", "\xff\xd8", 200, ".jpeg", "Good case, jpeg works"},
-	{"test.zip", "\x50\x4b\x03\x04", 200, ".zip", "Good case, zip works"},
+	{"test.jpeg", "\xff\xd8",
+		200, ".jpeg", "Good case, jpeg works"},
+	{"test.zip", "\x50\x4b\x03\x04",
+		200, ".zip", "Good case, zip works"},
 	{"test.txt", "\n", 200, ".txt", "Good case, txt works"},
 	{"test.owl", `<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"` +
-		`xmlns:owl="http://www.w3.org/2002/07/owl#"><owl:Ontology rdf:about=""/></rdf:RDF>`, 200, ".owl", "Good case, owl works"},
-	{"test.ttl", "@prefix : <#> .@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .", 200,
-		".ttl", "Good case, ttl works"},
+		`xmlns:owl="http://www.w3.org/2002/07/owl#"><owl:Ontology rdf:about=""/></rdf:RDF>`,
+		200, ".owl", "Good case, owl works"},
+	{"test.ttl", "@prefix : <#> .@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .",
+		200, ".ttl", "Good case, ttl works"},
 	{"test.html", "<!DOCTYPE html><html><head><title></title></head><body></body></html>",
 		200, ".html", "Good case, html works"},
-	{"test.csv", "id,name\n", 200, ".csv", "Good case, csv works"},
+	{"test.csv", "id,name\n",
+		200, ".csv", "Good case, csv works"},
 	{"test.mp4", "\x00\x00\x00\x18\x66\x74\x79\x70\x69\x73\x6f\x6d\x00\x00\x02\x00\x69\x73\x6f\x6d\x69\x73\x6f\x32",
 		200, ".mp4", "Good case, mp4 works"},
-	{"test.txt", "Internal Server Error\n", 500, ".txt", "Bad case, parsing url fails"},
-	{"wrong.txt", "Not Found\n", 404, ".txt", "Bad case, file not found"},
+	{"test.txt", "Internal Server Error\n",
+		500, ".txt", "Bad case, parsing url fails"},
+	{"wrong.txt", "Not Found\n",
+		404, ".txt", "Bad case, file not found"},
 }
 
 var fileTypeMap = map[string][]byte{
@@ -110,7 +116,8 @@ func TestTransferFile(t *testing.T) {
 		}
 
 		if inputW.Body.String() != testCase.expectedBody || inputW.Code != testCase.expectedCode {
-			t.Errorf("Expected: %s and %d, got: %s and %d", testCase.expectedBody, testCase.expectedCode, inputW.Body.String(), inputW.Code)
+			t.Errorf("Expected: %s and %d, got: %s and %d",
+				testCase.expectedBody, testCase.expectedCode, inputW.Body.String(), inputW.Code)
 		}
 	}
 
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index c139fe3..eed3b70 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -15,7 +15,7 @@ import (
 
 type stateParams struct {
 	testCer          *components.Cervice
-	testSys          *components.System
+	testSys          components.System
 	bodyBytes        []byte
 	body             func() *http.Response
 	mockTransportErr int
@@ -35,24 +35,26 @@ func newTestCerviceWithNodes() *components.Cervice {
 	}
 }
 
-var testCerviceWithoutNodes = components.Cervice{
-	IReferentce: "test",
-	Definition:  "A test Cervice without nodes",
-	Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
-	Nodes:       make(map[string][]string),
-	Protos:      []string{"http"},
+func newTestCerviceWithoutNodes() *components.Cervice {
+	return &components.Cervice{
+		IReferentce: "test",
+		Definition:  "A test Cervice without nodes",
+		Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
+		Nodes:       make(map[string][]string),
+		Protos:      []string{"http"},
+	}
 }
 
-var testCerviceWithBrokenUrl = components.Cervice{
-	IReferentce: "test",
-	Definition:  "A test Cervice with nodes",
-	Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
-	Nodes:       map[string][]string{"test": {brokenUrl}},
-	Protos:      []string{"http"},
+func newTestCerviceWithBrokenUrl() *components.Cervice {
+	return &components.Cervice{
+		IReferentce: "test",
+		Definition:  "A test Cervice with nodes",
+		Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
+		Nodes:       map[string][]string{"test": {brokenUrl}},
+		Protos:      []string{"http"},
+	}
 }
 
-var testSys = createTestSystem(false)
-
 var form forms.SignalA_v1a
 
 var errEmptyRespBody = errors.New("got empty response body")
@@ -60,7 +62,8 @@ var errEmptyRespBody = errors.New("got empty response body")
 var errUnpack = errors.New("problem unpacking response body")
 
 func createTestBytes() []byte {
-	return []byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}")
+	return []byte("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": " +
+		"\"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}")
 }
 
 func createWorkingHttpResp() func() *http.Response {
@@ -69,13 +72,15 @@ func createWorkingHttpResp() func() *http.Response {
 			Status:     "200 OK",
 			StatusCode: 200,
 			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			Body: io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n " +
+				" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
 		}
 	}
 	return httpResp
 }
 
-// This function creates two different http responses with a different body, since some tests build on receiving multiple correct http responses
+// This function creates two different http responses with a different body,
+// since some tests build on receiving multiple correct http responses
 func createDoubleHttpResp() func() *http.Response {
 	f := createServicePointTestForm()
 	// Create mock response from orchestrator
@@ -98,7 +103,8 @@ func createDoubleHttpResp() func() *http.Response {
 			Status:     "200 OK",
 			StatusCode: 200,
 			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			Body: io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n " +
+				" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
 		}
 	}
 }
@@ -121,7 +127,8 @@ func createStatusErrorHttpResp() func() *http.Response {
 			Status:     "300 NAK",
 			StatusCode: 300,
 			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			Body: io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n " +
+				" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
 		}
 	}
 	return httpResp
@@ -145,34 +152,47 @@ func createUnpackErrorHttpResp() func() *http.Response {
 			Status:     "200 OK",
 			StatusCode: 200,
 			Header:     http.Header{"Content-Type": []string{"Wrong content type"}},
-			Body:       io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+			Body: io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n " +
+				" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
 		}
 	}
 	return httpResp
 }
 
 var testStateParams = []stateParams{
-	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createWorkingHttpResp(), 0, nil, form.NewForm(), nil, "No errors with nodes"},
-	{&testCerviceWithoutNodes, &testSys, createTestBytes(), createDoubleHttpResp(), 0, nil, form.NewForm(), nil, "No errors without nodes"},
-	{newTestCerviceWithNodes(), &testSys, nil, createEmptyHttpResp(), 0, nil, nil, errEmptyRespBody, "Empty response body error"},
-	{&testCerviceWithoutNodes, &testSys, createTestBytes(), createWorkingHttpResp(), 1, errHTTP, nil, errHTTP, "Search4Services error"},
-	{&testCerviceWithBrokenUrl, &testSys, createTestBytes(), createWorkingHttpResp(), 2, errHTTP, nil, errHTTP, "NewRequest() error"},
-	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createStatusErrorHttpResp(), 2, errHTTP, nil, errHTTP, "Status code error"},
-	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createErrorReaderHttpResp(), 0, nil, nil, errBodyRead, "io.ReadAll() error"},
-	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createUnpackErrorHttpResp(), 0, nil, nil, errUnpack, "Unpack() error"},
-	{newTestCerviceWithNodes(), &testSys, createTestBytes(), createWorkingHttpResp(), 1, errHTTP, nil, errHTTP, "DefaultClient.Do() error"},
+	{newTestCerviceWithNodes(), createTestSystem(false), createTestBytes(),
+		createWorkingHttpResp(), 0, nil, form.NewForm(), nil, "No errors with nodes"},
+	{newTestCerviceWithoutNodes(), createTestSystem(false), createTestBytes(),
+		createDoubleHttpResp(), 0, nil, form.NewForm(), nil, "No errors without nodes"},
+	{newTestCerviceWithNodes(), createTestSystem(false), nil,
+		createEmptyHttpResp(), 0, nil, nil, errEmptyRespBody, "Empty response body error"},
+	{newTestCerviceWithoutNodes(), createTestSystem(false), createTestBytes(),
+		createWorkingHttpResp(), 1, errHTTP, nil, errHTTP, "Search4Services error"},
+	{newTestCerviceWithBrokenUrl(), createTestSystem(false), createTestBytes(),
+		createWorkingHttpResp(), 2, errHTTP, nil, errHTTP, "NewRequest() error"},
+	{newTestCerviceWithNodes(), createTestSystem(false), createTestBytes(),
+		createStatusErrorHttpResp(), 2, errHTTP, nil, errHTTP, "Status code error"},
+	{newTestCerviceWithNodes(), createTestSystem(false), createTestBytes(),
+		createErrorReaderHttpResp(), 0, nil, nil, errBodyRead, "io.ReadAll() error"},
+	{newTestCerviceWithNodes(), createTestSystem(false), createTestBytes(),
+		createUnpackErrorHttpResp(), 0, nil, nil, errUnpack, "Unpack() error"},
+	{newTestCerviceWithNodes(), createTestSystem(false), createTestBytes(),
+		createWorkingHttpResp(), 1, errHTTP, nil, errHTTP, "DefaultClient.Do() error"},
 }
 
 func TestGetState(t *testing.T) {
 	for _, test := range testStateParams {
 		newMockTransport(test.body, test.mockTransportErr, test.errHTTP)
-		res, err := GetState(test.testCer, test.testSys)
+		res, err := GetState(test.testCer, &test.testSys)
 
 		if test.expectedfForm != nil {
 			expected := test.expectedfForm.(*forms.SignalA_v1a)
 			actual := res.(*forms.SignalA_v1a)
-			if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
-				t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
+			if expected.Value != actual.Value || expected.Unit != actual.Unit ||
+				expected.Timestamp != actual.Timestamp || expected.Version != actual.Version ||
+				err != test.expectedErr {
+				t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v",
+					test.testCase, err, expected, actual)
 			}
 		} else if err == nil {
 			t.Errorf("Test case: %s got error: %v:", test.testCase, err)
@@ -190,13 +210,16 @@ func TestSetState(t *testing.T) {
 		if test.testCase == "No errors without nodes" {
 			test.testCer.Nodes = make(map[string][]string)
 		}
-		res, err := SetState(test.testCer, test.testSys, test.bodyBytes)
+		res, err := SetState(test.testCer, &test.testSys, test.bodyBytes)
 
 		if test.expectedfForm != nil {
 			expected := test.expectedfForm.(*forms.SignalA_v1a)
 			actual := res.(*forms.SignalA_v1a)
-			if expected.Value != actual.Value || expected.Unit != actual.Unit || expected.Timestamp != actual.Timestamp || expected.Version != actual.Version || err != test.expectedErr {
-				t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v", test.testCase, err, expected, actual)
+			if expected.Value != actual.Value || expected.Unit != actual.Unit ||
+				expected.Timestamp != actual.Timestamp || expected.Version != actual.Version ||
+				err != test.expectedErr {
+				t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v",
+					test.testCase, err, expected, actual)
 			}
 		} else if err == nil {
 			t.Errorf("Test case: %s got error: %v:", test.testCase, err)
diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index ec2e911..42e2f18 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -56,7 +56,8 @@ func createBrokenForm() mockForm {
 
 var httpProcessGetRequestParams = []httpProcessGetRequestStruct{
 	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n}", form.NewForm(),
-		"{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}", "Good case"},
+		"{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n " +
+			" \"version\": \"SignalA_v1.0\"\n}", "Good case"},
 	{httptest.NewRecorder(), "<form><value>0</value><unit></unit></form>", nil,
 		"No payload found.\n", "Bad case, form is nil"},
 	{httptest.NewRecorder(), "\n", createEmptyFormVersion(),
@@ -101,16 +102,21 @@ func createForm() forms.SignalA_v1a {
 }
 
 var httpProcessSetRequestParams = []httpProcessSetRequestStruct{
-	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}",
+	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n " +
+		" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}",
 		false, createForm(), "Good case"},
 	{httptest.NewRecorder(), "\n", true, forms.SignalA_v1a{}, "Bad case, Unmarshal returns error"},
-	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"bersion\": \"SignalA_v1.0\"\n}",
+	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n " +
+		" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"bersion\": \"SignalA_v1.0\"\n}",
 		true, forms.SignalA_v1a{}, "Bad case, version key missing"},
-	{httptest.NewRecorder(), "{\n  \"value\": \"not-a-number\",\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}",
+	{httptest.NewRecorder(), "{\n  \"value\": \"not-a-number\",\n  \"unit\": \"\",\n " +
+		" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}",
 		true, forms.SignalA_v1a{}, "Bad case, Second Unmarshal breaks"},
-	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}",
+	{httptest.NewRecorder(), "{\n  \"value\": 0,\n  \"unit\": \"\",\n " +
+		" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}",
 		true, forms.SignalA_v1a{}, "Bad case, version is wrong"},
-	{httptest.NewRecorder(), "{\n  \"value\": false,\n  \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}",
+	{httptest.NewRecorder(), "{\n  \"value\": false,\n " +
+		" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalB_v1.0\"\n}",
 		true, forms.SignalA_v1a{}, "Bad case, form version is SignalB_v1a"},
 }
 
@@ -120,7 +126,8 @@ func TestHTTPProcessSetRequest(t *testing.T) {
 		inputR.Header.Set("Content-Type", "application/json")
 		f, err := HTTPProcessSetRequest(testCase.inputW, inputR)
 
-		if f != testCase.expectedForm || (err == nil && testCase.expectedErr == true) || (err != nil && testCase.expectedErr == false) {
+		if f != testCase.expectedForm || (err == nil && testCase.expectedErr == true) ||
+			(err != nil && testCase.expectedErr == false) {
 			t.Errorf("Expected %v and %v, got: %v and %v", testCase.expectedForm, testCase.expectedErr, f, err)
 		}
 	}
@@ -143,12 +150,18 @@ type getBestContentTypeStruct struct {
 }
 
 var getBestContentTypeParams = []getBestContentTypeStruct{
-	{"", "application/json", "Good case, no accept header provided"},
-	{"application/xml", "application/xml", "Good case, accept header provided without q-values"},
-	{"application/xml;q=0.7, application/json;q=0.9", "application/json", "Good case, accept header provided with q-values"},
-	{"application/xml;q=wrong, application/json;q=1.1", "application/json", "Good case, xml gets skipped"},
-	{"application/xml;q=0.9, application/json;q=0.9", "application/xml", "Good case, equal q-values selects the first one"},
-	{"application/xml;q=-0.9", "application/json", "Good case, no MIME type found"},
+	{"", "application/json",
+		"Good case, no accept header provided"},
+	{"application/xml", "application/xml",
+		"Good case, accept header provided without q-values"},
+	{"application/xml;q=0.7, application/json;q=0.9", "application/json",
+		"Good case, accept header provided with q-values"},
+	{"application/xml;q=wrong, application/json;q=1.1", "application/json",
+		"Good case, xml gets skipped"},
+	{"application/xml;q=0.9, application/json;q=0.9", "application/xml",
+		"Good case, equal q-values selects the first one"},
+	{"application/xml;q=-0.9", "application/json",
+		"Good case, no MIME type found"},
 }
 
 func TestGetBestContentType(t *testing.T) {
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 8779fd8..5d6ba44 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -71,14 +71,16 @@ func TestDeepCopyMap(t *testing.T) {
 		// If they are not equal from the beginning then the copy was not successful
 		err := manualEqualityCheck(original, test)
 		if err != nil {
-			t.Errorf("In test case: %s: Expected deep copied map to be equal to original, Expected: %v, got: %v", testCase.testName, original, test)
+			t.Errorf("In test case: %s: Expected deep copied map to be equal to original,"+
+				" Expected: %v, got: %v", testCase.testName, original, test)
 		}
 
 		// When we change something in the original, the deep copied map should not change
 		original["Test"][0] = "changed original"
 		err = manualEqualityCheck(original, test)
 		if err == nil {
-			t.Errorf("In test case: %s: Deep copy failed, changes in original affected the deep copied map. Expected: %v, got %v", testCase.testName, original, test)
+			t.Errorf("In test case: %s: Deep copy failed, changes in original affected the deep copied map."+
+				" Expected: %v, got %v", testCase.testName, original, test)
 		}
 		original["Test"][0] = "test"
 
@@ -86,7 +88,8 @@ func TestDeepCopyMap(t *testing.T) {
 		test["Test"][0] = "changed deep copy"
 		err = manualEqualityCheck(original, test)
 		if err == nil {
-			t.Errorf("In test case: %s: Deep copy failed, changes in deep copied map affected the original. Expected: %v, got %v", testCase.testName, original, test)
+			t.Errorf("In test case: %s: Deep copy failed, changes in deep copied map affected the original."+
+				" Expected: %v, got %v", testCase.testName, original, test)
 		}
 	}
 }
@@ -145,7 +148,8 @@ func TestServiceRegistrationForm(t *testing.T) {
 	}
 
 	// Special case
-	// Check that when the Service RegPeriod equals 0, ServiceRegistrationForm defaults to its RegLife default value of 30
+	// Check that when the Service RegPeriod equals 0,
+	// ServiceRegistrationForm defaults to its RegLife default value of 30
 	testSys := createTestSystem(false)
 	mua := testSys.UAssets["testUnitAsset"]
 	serv := (*testSys.UAssets["testUnitAsset"]).GetServices()["test"]
@@ -197,7 +201,8 @@ func TestServiceRegistrationFormList(t *testing.T) {
 	list := []string{
 		"ServiceRecord_v1",
 	}
-	// Check that the return value of ServiceRegistrationFormsList is equal to the expected list of ServiceRegistrationForms
+	// Check that the return value of ServiceRegistrationFormsList is equal
+	// to the expected list of ServiceRegistrationForms
 	test := ServiceRegistrationFormsList()
 	for i := range list {
 		if list[i] != test[i] {
@@ -219,8 +224,10 @@ type registerServiceTestStruct struct {
 	testName         string
 }
 
-func createWorkingRegisterServiceBody(mua *components.UnitAsset, serv *components.Service, correctTime bool, contentType string, brokenBody bool) func() *http.Response {
-	payload, err := serviceRegistrationForm(&testSys, mua, serv, "ServiceRecord_v1")
+func createWorkingRegisterServiceBody(mockSys components.System, mua *components.UnitAsset, serv *components.Service,
+	correctTime bool, contentType string, brokenBody bool) func() *http.Response {
+
+	payload, err := serviceRegistrationForm(&mockSys, mua, serv, "ServiceRecord_v1")
 	if err != nil {
 		log.Fatalf("The service Record version was wrong")
 	}
@@ -262,7 +269,8 @@ func createWorkingRegisterServiceBody(mua *components.UnitAsset, serv *component
 	}
 }
 
-func createMockSysMockUnitAssetandMockService(id int) (mockSys components.System, mua *components.UnitAsset, mockServ *components.Service) {
+func createMockSysMockUnitAssetandMockService(id int) (mockSys components.System, mua *components.UnitAsset,
+	mockServ *components.Service) {
 	mockSys = createTestSystem(false)
 	mua = mockSys.UAssets["testUnitAsset"]
 	mockServ = (*mockSys.UAssets["testUnitAsset"]).GetServices()["test"]
@@ -271,16 +279,26 @@ func createMockSysMockUnitAssetandMockService(id int) (mockSys components.System
 }
 
 var registerServiceTestParams = []registerServiceTestStruct{
-	{"https://leadingregistrar", "application/json", 1, true, false, false, 0, nil, "Good case, with PUT method"},
-	{"https://leadingregistrar", "application/json", 0, true, false, false, 0, nil, "Good case, with POST method"},
-	{"https://leadingregistrar", "application/json", 1, true, false, true, 1, timeoutError{}, "Bad case, timeout error"},
-	{"https://leadingregistrar", "application/json", 1, true, false, true, 1, errHTTP, "Bad case, error in defaultClint"},
-	{"https://leadingregistrar", "application/json", 1, true, true, true, 0, nil, "Bad case, error in ReadAll"},
-	{"https://leadingregistrar", "", 1, true, false, true, 0, nil, "Bad case, error in Unpack"},
-	{"https://leadingregistrar", "application/json", 1, false, false, true, 0, nil, "Bad case, error parsing time"},
-	{"", "application/json", 1, true, false, false, 0, nil, "Good case, no leading registrar URL sent in"},
-	{brokenUrl, "application/json", 1, true, false, true, 0, nil, "Bad case, broken URL with PUT method"},
-	{brokenUrl, "application/json", 0, true, false, true, 0, nil, "Bad case, broken URL with POST method"},
+	{"https://leadingregistrar", "application/json", 1, true, false, false, 0, nil,
+		"Good case, with PUT method"},
+	{"https://leadingregistrar", "application/json", 0, true, false, false, 0, nil,
+		"Good case, with POST method"},
+	{"https://leadingregistrar", "application/json", 1, true, false, true, 1, timeoutError{},
+		"Bad case, timeout error"},
+	{"https://leadingregistrar", "application/json", 1, true, false, true, 1, errHTTP,
+		"Bad case, error in defaultClint"},
+	{"https://leadingregistrar", "application/json", 1, true, true, true, 0, nil,
+		"Bad case, error in ReadAll"},
+	{"https://leadingregistrar", "", 1, true, false, true, 0, nil,
+		"Bad case, error in Unpack"},
+	{"https://leadingregistrar", "application/json", 1, false, false, true, 0, nil,
+		"Bad case, error parsing time"},
+	{"", "application/json", 1, true, false, false, 0, nil,
+		"Good case, no leading registrar URL sent in"},
+	{brokenUrl, "application/json", 1, true, false, true, 0, nil,
+		"Bad case, broken URL with PUT method"},
+	{brokenUrl, "application/json", 0, true, false, true, 0, nil,
+		"Bad case, broken URL with POST method"},
 }
 
 var delay = time.Duration(15) * time.Second
@@ -288,7 +306,8 @@ var delay = time.Duration(15) * time.Second
 func TestRegisterService(t *testing.T) {
 	for _, testCase := range registerServiceTestParams {
 		mockSys, mua, mockServ := createMockSysMockUnitAssetandMockService(testCase.mockServID)
-		respFunc := createWorkingRegisterServiceBody(mua, mockServ, testCase.correctTime, testCase.contentType, testCase.brokenBody)
+		respFunc := createWorkingRegisterServiceBody(mockSys, mua, mockServ, testCase.correctTime,
+			testCase.contentType, testCase.brokenBody)
 		newMockTransport(respFunc, testCase.mockTransportErr, testCase.errHTTP)
 
 		test, err := registerService(&mockSys, testCase.registrarUrl, mua, mockServ)
@@ -296,18 +315,21 @@ func TestRegisterService(t *testing.T) {
 		// Special case
 		if testCase.registrarUrl == "" {
 			if err != nil || test != delay {
-				t.Errorf("In test case: %s: Did we expect error? %t, got: %v and %d delay.", testCase.testName, testCase.expectedErr, err, test)
+				t.Errorf("In test case: %s: Did we expect error? %t, got: %v and %d delay.",
+					testCase.testName, testCase.expectedErr, err, test)
 			}
 			continue
 		}
 
 		if testCase.expectedErr == false {
 			if err != nil || test == delay {
-				t.Errorf("In test case: %s: Did we expect error? %t, got: %v and %d delay.", testCase.testName, testCase.expectedErr, err, test)
+				t.Errorf("In test case: %s: Did we expect error? %t, got: %v and %d delay.",
+					testCase.testName, testCase.expectedErr, err, test)
 			}
 		} else {
 			if err == nil || test != delay {
-				t.Errorf("In test case: %s: Did we expect error? %t, got: %v and %d delay.", testCase.testName, testCase.expectedErr, err, test)
+				t.Errorf("In test case: %s: Did we expect error? %t, got: %v and %d delay.",
+					testCase.testName, testCase.expectedErr, err, test)
 			}
 		}
 	}

From 8b4ee5b0f01e1a2e8051d437642e764408414ef4 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Wed, 9 Jul 2025 13:58:16 +0200
Subject: [PATCH 148/186] Fixed PR comments

---
 usecases/registration.go      |  3 ++
 usecases/registration_test.go | 72 +++++++++++------------------------
 2 files changed, 25 insertions(+), 50 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index 5a4c725..31028a6 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -176,6 +176,9 @@ func registerService(sys *components.System, registrar string, ua *components.Un
 	}
 	// should not wait until the deadline to start to confirm live status
 	delay = time.Until(parsedTime.Add(-5 * time.Second))
+	if delay < 30*time.Second {
+		delay = 30 * time.Second
+	}
 	return
 }
 
diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 5d6ba44..3606ee8 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -52,45 +52,32 @@ func manualEqualityCheck(map1 map[string][]string, map2 map[string][]string) err
 	return nil
 }
 
-type deepCopyMapTestStruct struct {
-	mockSystem components.System
-	testName   string
-}
-
-var deepCopyMapTestParams = []deepCopyMapTestStruct{
-	{createTestSystem(false), "Good case, the copy works as a deep copy"},
-}
-
 func TestDeepCopyMap(t *testing.T) {
-	for _, testCase := range deepCopyMapTestParams {
-		mua := testCase.mockSystem.UAssets["testUnitAsset"]
-		original := (*mua).GetDetails()
+	var original = map[string][]string{"a": {"1", "2"}, "b": {"3"}}
 
-		test := deepCopyMap((*mua).GetDetails())
+	test := deepCopyMap(original)
 
-		// If they are not equal from the beginning then the copy was not successful
-		err := manualEqualityCheck(original, test)
-		if err != nil {
-			t.Errorf("In test case: %s: Expected deep copied map to be equal to original,"+
-				" Expected: %v, got: %v", testCase.testName, original, test)
-		}
+	// If they are not equal from the beginning then the copy was not successful
+	err := manualEqualityCheck(original, test)
+	if err != nil {
+		t.Errorf("Expected deep copied map to be equal to original, Expected: %v, got: %v", original, test)
+	}
 
-		// When we change something in the original, the deep copied map should not change
-		original["Test"][0] = "changed original"
-		err = manualEqualityCheck(original, test)
-		if err == nil {
-			t.Errorf("In test case: %s: Deep copy failed, changes in original affected the deep copied map."+
-				" Expected: %v, got %v", testCase.testName, original, test)
-		}
-		original["Test"][0] = "test"
-
-		// When we change something in the deep copied map, the original should not change
-		test["Test"][0] = "changed deep copy"
-		err = manualEqualityCheck(original, test)
-		if err == nil {
-			t.Errorf("In test case: %s: Deep copy failed, changes in deep copied map affected the original."+
-				" Expected: %v, got %v", testCase.testName, original, test)
-		}
+	// When we change something in the original, the deep copied map should not change
+	original["a"][0] = "changed original"
+	err = manualEqualityCheck(original, test)
+	if err == nil {
+		t.Errorf("Deep copy failed, changes in original affected the deep copied map."+
+			" Expected: %v, got %v", original, test)
+	}
+	original["a"][0] = "1"
+
+	// When we change something in the deep copied map, the original should not change
+	test["a"][0] = "changed deep copy"
+	err = manualEqualityCheck(original, test)
+	if err == nil {
+		t.Errorf("Deep copy failed, changes in deep copied map affected the original."+
+			" Expected: %v, got %v", original, test)
 	}
 }
 
@@ -197,21 +184,6 @@ func TestUnregisterService(t *testing.T) {
 	}
 }
 
-func TestServiceRegistrationFormList(t *testing.T) {
-	list := []string{
-		"ServiceRecord_v1",
-	}
-	// Check that the return value of ServiceRegistrationFormsList is equal
-	// to the expected list of ServiceRegistrationForms
-	test := ServiceRegistrationFormsList()
-	for i := range list {
-		if list[i] != test[i] {
-			t.Errorf("Expected lists to be equal. Expected: %v, got: %v", list, test)
-			break
-		}
-	}
-}
-
 type registerServiceTestStruct struct {
 	registrarUrl     string
 	contentType      string

From 67831361538d6321a938ff33395d39d0a2bc8568 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Thu, 10 Jul 2025 09:45:15 +0200
Subject: [PATCH 149/186] Moved around some code in components/service_test.go
 to make it more readable

---
 components/service_test.go | 172 ++++++++++++++++++-------------------
 1 file changed, 86 insertions(+), 86 deletions(-)

diff --git a/components/service_test.go b/components/service_test.go
index f7c054c..3c400b2 100644
--- a/components/service_test.go
+++ b/components/service_test.go
@@ -5,45 +5,65 @@ import (
 	"testing"
 )
 
-type mergeDetailsTestStruct struct {
-	map1     map[string][]string
-	map2     map[string][]string
-	expected map[string][]string
+func manualEqualityCheck(map1 map[string][]string, map2 map[string][]string) error {
+	if len(map1) != len(map2) {
+		return fmt.Errorf("Expected map length %d, got %d", len(map2), len(map1))
+	}
+	for key, value := range map2 {
+		mv, ok := map1[key]
+		if !ok {
+			return fmt.Errorf("Expected key %q not found in merged map", key)
+		}
+		if len(mv) != len(value) {
+			return fmt.Errorf("For key %q, expected slice length %d, got %d", key, len(value), len(mv))
+		}
+		for i := range value {
+			if mv[i] != value[i] {
+				return fmt.Errorf("For key %q, at index %d, expected %q, got %q", key, i, value[i], mv[i])
+			}
+		}
+	}
+	for key := range map1 {
+		if _, ok := map2[key]; !ok {
+			return fmt.Errorf("Unexpected key %q found in merged map", key)
+		}
+	}
+	return nil
 }
 
-var testService = Service{
+var testServiceWithEmptyDetails = Service{
 	ID:            1,
-	Definition:    "test",
-	SubPath:       "testSubPath",
+	Definition:    "original one",
+	SubPath:       "testOriginalSubPath",
 	Details:       make(map[string][]string),
 	RegPeriod:     45,
 	RegTimestamp:  "",
 	RegExpiration: "",
-	Description:   "A test service",
+	Description:   "A test original service",
 	SubscribeAble: false,
 	ACost:         0,
 	CUnit:         "",
 }
 
-var testOriginalService = Service{
+var testService = Service{
 	ID:            1,
-	Definition:    "original one",
-	SubPath:       "testOriginalSubPath",
-	Details:       map[string][]string{"test": {"test1", "test2"}},
+	Definition:    "test",
+	SubPath:       "testSubPath",
+	Details:       make(map[string][]string),
 	RegPeriod:     45,
 	RegTimestamp:  "",
 	RegExpiration: "",
-	Description:   "A test original service",
+	Description:   "A test service",
 	SubscribeAble: false,
 	ACost:         0,
 	CUnit:         "",
 }
 
-var testServiceWithEmptyDetails = Service{
+var testOriginalService = Service{
 	ID:            1,
 	Definition:    "original one",
 	SubPath:       "testOriginalSubPath",
-	Details:       make(map[string][]string),
+	Details:       map[string][]string{"test": {"test1", "test2"}},
 	RegPeriod:     45,
 	RegTimestamp:  "",
 	RegExpiration: "",
@@ -53,77 +73,6 @@ var testServiceWithEmptyDetails = Service{
 	CUnit:         "",
 }
 
-func makeNewTestService(id int, definition string) *Service {
-	return &Service{
-		ID:            id,
-		Definition:    definition,
-		SubPath:       "newTestServiceSubPath",
-		Details:       make(map[string][]string),
-		RegPeriod:     45,
-		RegTimestamp:  "",
-		RegExpiration: "",
-		Description:   "A new test Service",
-		SubscribeAble: false,
-		ACost:         0,
-		CUnit:         "",
-	}
-}
-
-func makeNewMap(key string, value string) map[string][]string {
-	newMap := map[string][]string{
-		key: {value},
-	}
-	return newMap
-}
-
-var expectedRegularMerge = map[string][]string{
-	"a": {"1"},
-	"b": {"2"},
-}
-
-var expectedKeyOverlapMerge = map[string][]string{
-	"a": {"1", "3"},
-}
-
-var expectedOneEmptyMapMerge = map[string][]string{
-	"a": {"1"},
-}
-
-var expectedBothEmptyMapMerge = map[string][]string{}
-
-var mergeDetailsTestParams = []mergeDetailsTestStruct{
-	{makeNewMap("a", "1"), makeNewMap("b", "2"), expectedRegularMerge},
-	{makeNewMap("a", "1"), makeNewMap("a", "3"), expectedKeyOverlapMerge},
-	{makeNewMap("a", "1"), make(map[string][]string), expectedOneEmptyMapMerge},
-	{make(map[string][]string), make(map[string][]string), expectedBothEmptyMapMerge},
-}
-
-func manualEqualityCheck(map1 map[string][]string, map2 map[string][]string) error {
-	if len(map1) != len(map2) {
-		return fmt.Errorf("Expected map length %d, got %d", len(map2), len(map1))
-	}
-	for key, value := range map2 {
-		mv, ok := map1[key]
-		if !ok {
-			return fmt.Errorf("Expected key %q not found in merged map", key)
-		}
-		if len(mv) != len(value) {
-			return fmt.Errorf("For key %q, expected slice length %d, got %d", key, len(value), len(mv))
-		}
-		for i := range value {
-			if mv[i] != value[i] {
-				return fmt.Errorf("For key %q, at index %d, expected %q, got %q", key, i, value[i], mv[i])
-			}
-		}
-	}
-	for key := range map1 {
-		if _, ok := map2[key]; !ok {
-			return fmt.Errorf("Unexpected key %q found in merged map", key)
-		}
-	}
-	return nil
-}
-
 func TestMerge(t *testing.T) {
 	testService.Merge(&testOriginalService)
 	if testService.Definition != testOriginalService.Definition ||
@@ -152,6 +101,22 @@ func TestDeepCopy(t *testing.T) {
 	}
 }
 
+func makeNewTestService(id int, definition string) *Service {
+	return &Service{
+		ID:            id,
+		Definition:    definition,
+		SubPath:       "newTestServiceSubPath",
+		Details:       make(map[string][]string),
+		RegPeriod:     45,
+		RegTimestamp:  "",
+		RegExpiration: "",
+		Description:   "A new test Service",
+		SubscribeAble: false,
+		ACost:         0,
+		CUnit:         "",
+	}
+}
+
 func TestCloneServices(t *testing.T) {
 	test1 := makeNewTestService(1, "test")
 	test2 := makeNewTestService(2, "test")
@@ -187,6 +152,41 @@ func TestCloneServices(t *testing.T) {
 	}
 }
 
+func makeNewMap(key string, value string) map[string][]string {
+	newMap := map[string][]string{
+		key: {value},
+	}
+	return newMap
+}
+
+var expectedRegularMerge = map[string][]string{
+	"a": {"1"},
+	"b": {"2"},
+}
+
+var expectedKeyOverlapMerge = map[string][]string{
+	"a": {"1", "3"},
+}
+
+var expectedOneEmptyMapMerge = map[string][]string{
+	"a": {"1"},
+}
+
+var expectedBothEmptyMapMerge = map[string][]string{}
+
+type mergeDetailsTestStruct struct {
+	map1     map[string][]string
+	map2     map[string][]string
+	expected map[string][]string
+}
+
+var mergeDetailsTestParams = []mergeDetailsTestStruct{
+	{makeNewMap("a", "1"), makeNewMap("b", "2"), expectedRegularMerge},
+	{makeNewMap("a", "1"), makeNewMap("a", "3"), expectedKeyOverlapMerge},
+	{makeNewMap("a", "1"), make(map[string][]string), expectedOneEmptyMapMerge},
+	{make(map[string][]string), make(map[string][]string), expectedBothEmptyMapMerge},
+}
+
 func TestMergeDetails(t *testing.T) {
 	for _, test := range mergeDetailsTestParams {
 		merged := MergeDetails(test.map1, test.map2)

From 569c23b2d7364b954b42f3407c09872ba05d6efd Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 9 Jul 2025 09:22:51 +0200
Subject: [PATCH 150/186] Fixes linter error about copying sync.Map

---
 components/system.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/components/system.go b/components/system.go
index c65a60a..c9054d1 100644
--- a/components/system.go
+++ b/components/system.go
@@ -44,7 +44,7 @@ type System struct {
 	Ctx           context.Context       // create a context that can be cancelled
 	Sigs          chan os.Signal        // channel to initiate a graceful shutdown when Ctrl+C is pressed
 	RegistrarChan chan *CoreSystem      // channel for the lead service registrar
-	Messengers    sync.Map              // Tracks which hosts to send log msgs to (and how many errors were encountered, before being removed)
+	Messengers    *sync.Map             // Tracks which hosts to send log msgs to (and how many errors were encountered, before being removed)
 }
 
 // CoreSystem struct holds details about the core system included in the configuration file
@@ -63,6 +63,13 @@ func NewSystem(name string, ctx context.Context) System {
 	newSystem.RegistrarChan = make(chan *CoreSystem, 1)
 	newSystem.Host = NewDevice()
 	newSystem.UAssets = make(map[string]*UnitAsset) // initialize UAsset as an empty map
+	// Since the return System isn't a pointer (incorrectly), this map needs to
+	// be a pointer instead (usually not normal) and initialised (usually not needed)
+	// in order to avoid linter errors.
+	// The errors is due to this func returning a copy of newSystem and attempts
+	// to copy the map too, but it's not allowed for sync objects.
+	// Reference: https://stackoverflow.com/questions/37242009/function-returns-lock-by-value
+	newSystem.Messengers = &sync.Map{}
 	return newSystem
 }
 

From cd76780f8e73f1a4df0855ce1ab299ce200563d6 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Wed, 9 Jul 2025 10:45:28 +0200
Subject: [PATCH 151/186] converted Search4Service() and Search4Services() to
 table driven tests

---
 usecases/service_discovery_test.go | 372 +++++++++++++++--------------
 1 file changed, 198 insertions(+), 174 deletions(-)

diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index 332f28c..4b8b9d9 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -6,10 +6,12 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"strings"
 	"testing"
 
+	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
 )
 
@@ -212,205 +214,218 @@ func TestSendHttpReq(t *testing.T) {
 	}
 }
 
-func TestSearch4Service(t *testing.T) {
-	// Best case, everything pass
+// --------------------------------------------------------- //
+// Helper functions and structs for testing Search4Service()
+// --------------------------------------------------------- //
+
+type search4ServiceParams struct {
+	expectError bool
+	response    func() *http.Response
+	transport   func(func() *http.Response) *mockTransport
+	testCase    string
+}
+
+// This function returns different http responses depending on the number of times it's read
+// allowedReads takes a positive number, and will count back from that number until it reaches 0, then return a
+// http.Response with errReader() in body, given 0 or negative number it'll always return a functioning http.Response
+func createMultiHttpResp(statusCode int, broken bool, allowedReads int) func() *http.Response {
 	f := createServicePointTestForm()
 	// Create mock response from orchestrator
 	fakeBody, err := json.Marshal(f)
 	if err != nil {
-		t.Errorf("Fail Marshal at start of test")
-	}
-	resp := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+		log.Println("Fail Marshal at start of test")
+	}
+	count := allowedReads
+	return func() *http.Response {
+		count--
+		if broken == true && count == 0 {
+			return &http.Response{
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       errReader(0),
+			}
 		}
-	}
-	newMockTransport(resp, 0, nil)
-	testSys := createTestSystem(false)
-	var qForm forms.ServiceQuest_v1
-	serviceForm, err := Search4Service(qForm, &testSys)
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-	if serviceForm.ServLocation != f.ServLocation {
-		t.Errorf("Expected %s, got: %s", f.ServLocation, serviceForm.ServLocation)
-	}
-
-	// Error at "prepare the payload to perform a service quest"
-	// Untested because I found no way of breaking json.Marshal, without making big changes to the form
-
-	// Error while getting core system url
-	newMockTransport(resp, 1, errHTTP)
-	qForm.NewForm()
-	_, err = Search4Service(qForm, &testSys)
-	if err == nil {
-		t.Errorf("Expected error at GetRunningCoreSystemURL()")
-	}
-
-	// Error at sendHttpRequest
-	resp = func() *http.Response {
 		return &http.Response{
-			Status:     "200 ?",
-			StatusCode: 200,
+			StatusCode: statusCode,
 			Header:     http.Header{"Content-Type": []string{"application/json"}},
 			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
 		}
 	}
-	newMockTransport(resp, 2, errHTTP)
-	qForm.NewForm()
-	_, err = Search4Service(qForm, &testSys)
-	if err == nil {
-		t.Errorf("Expected error at sendHttpRequest()")
-	}
+}
 
-	// Non-2xx status code of response from sendHttpRequest()
-	resp = func() *http.Response {
-		return &http.Response{
-			Status:     "300 ?",
-			StatusCode: 300,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
-		}
-	}
-	newMockTransport(resp, 0, nil)
-	qForm.NewForm()
-	_, err = Search4Service(qForm, &testSys)
-	if err == nil {
-		t.Errorf("Expected error at sendHttpRequest")
+func TestSearch4Service(t *testing.T) {
+	// Test parameters
+	params := []search4ServiceParams{
+		//{ expectError, response, transport, testCase }
+		{
+			false,
+			createMultiHttpResp(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Best case",
+		},
+		{
+			true,
+			createMultiHttpResp(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 1, errHTTP) },
+			"Bad case, error getting core system url",
+		},
+		{
+			true,
+			createMultiHttpResp(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 2, errHTTP) },
+			"Bad case, error sending http request",
+		},
+		{
+			true,
+			createMultiHttpResp(200, true, 2),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Bad case, error reading response body",
+		},
 	}
-
-	// Error at "Read the response", io.ReadAll()
-	resp = func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       errReader(0),
+	testSys := createTestSystem(false)
+	for _, c := range params {
+		// Setup
+		c.transport(c.response)
+		var qForm forms.ServiceQuest_v1
+		qForm.NewForm()
+
+		// Test
+		_, err := Search4Service(qForm, &testSys)
+		if c.expectError == false && err != nil {
+			t.Errorf("Expected no errors in testcase '%s', got: %v", c.testCase, err)
 		}
-	}
-	f = createServicePointTestForm()
-	newMockTransport(resp, 0, nil)
-	qForm.NewForm()
-	serviceForm, err = Search4Service(qForm, &testSys)
-	if err == nil {
-		t.Errorf("Expected error")
-	}
-
-	// Error at "Read the response", ExtractDiscoveryForm()
-	f = createServicePointTestForm()
-	resp = func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string("test"))),
+		if c.expectError == true && err == nil {
+			t.Errorf("Expected errors in testcase '%s'", c.testCase)
 		}
 	}
-	newMockTransport(resp, 0, nil)
-	qForm.NewForm()
-	serviceForm, err = Search4Service(qForm, &testSys)
-	if err == nil {
-		t.Errorf("Expected error")
-	}
 }
 
-// Used to create a ServicePoint_v1 form for testing purposes
-func createTestServicePoint() (f forms.ServicePoint_v1) {
-	f.ProviderName = "testProvider"
-	f.ServiceDefinition = "testDef"
-	f.Details = map[string][]string{
-		"Details": {"detail1", "detail2"},
-	}
-	f.Version = "ServicePoint_v1"
-	return
+// --------------------------------------------------------- //
+// Helper functions and structs for testing Search4Services()
+// --------------------------------------------------------- //
+
+type search4ServicesParams struct {
+	expectError bool
+	setup       func() (*components.Cervice, components.System)
+	response    func() *http.Response
+	transport   func(func() *http.Response) *mockTransport
+	testCase    string
 }
 
 func TestSearch4Services(t *testing.T) {
-	// Best case: everything passes
-	fakeBody := createTestServicePoint()
-	data, err := json.Marshal(fakeBody)
-	if err != nil {
-		t.Error("Error in test during json.Marshal()")
-	}
-	resp := func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       io.NopCloser(strings.NewReader(string(data))),
-		}
-	}
-	newMockTransport(resp, 0, nil)
-	testSys := createTestSystem(false)
-	cer := (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-	err = Search4Services(cer, &testSys)
-	if err != nil {
-		t.Errorf("Expected no errors, got %v", err)
-	}
-
-	// Bad case: GetRunningCoreSystemURL() returns error
-	newMockTransport(resp, 1, errHTTP)
-	err = Search4Services(cer, &testSys)
-	if err == nil {
-		t.Errorf("Expected errors")
-	}
-
-	// Bad case: Orchestrator url is ""
-	newMockTransport(resp, 0, nil)
-	for i, cs := range testSys.CoreS {
-		if cs.Name == "orchestrator" {
-			(*testSys.CoreS[i]).Url = ""
-		}
-	}
-	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-	err = Search4Services(cer, &testSys)
-	if err == nil {
-		t.Errorf("Expected errors")
+	params := []search4ServicesParams{
+		{
+			false,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpResp(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Best case, no errors",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpResp(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 1, errHTTP) },
+			"Bad case, GetRunningCoreSystemURL() returns error",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				for i, cs := range sys.CoreS {
+					if cs.Name == "orchestrator" {
+						(*sys.CoreS[i]).Url = ""
+					}
+				}
+				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpResp(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Bad case, Orchestrator url is empty",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpResp(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 2, errHTTP) },
+			"Bad case, sendHttpReq() returns an error",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpResp(200, true, 2),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Bad case, error while reading body",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			func() *http.Response {
+				return &http.Response{
+					Status:     "200 OK",
+					StatusCode: 200,
+					Header:     http.Header{"Content-Type": []string{"Error"}},
+					Body:       io.NopCloser(strings.NewReader(string(""))),
+				}
+			},
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Bad case, error during Unpack",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			func() *http.Response {
+				return &http.Response{
+					Status:     "200 OK",
+					StatusCode: 200,
+					Header:     http.Header{"Content-Type": []string{"application/json"}},
+					Body:       io.NopCloser(strings.NewReader(string(`{"version":"SignalA_v1.0"}`))),
+				}
+			},
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Bad case, error during type conversion",
+		},
 	}
 
-	// Bad case: sendHttpReq() returns an error
-	newMockTransport(resp, 2, nil)
-	testSys = createTestSystem(false) // Needed otherwise we don't get past the orchestrator error handlers
-	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-	err = Search4Services(cer, &testSys)
-	if err == nil {
-		t.Errorf("Expected errors")
-	}
-
-	// Bad case: io.ReadAll() return an error
-	resp = func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"application/json"}},
-			Body:       errReader(0),
+	for _, c := range params {
+		// Setup
+		c.transport(c.response)
+		cer, sys := c.setup()
+
+		// Test
+		err := Search4Services(cer, &sys)
+		if (c.expectError == false) && (err != nil) {
+			t.Errorf("Expected no errors in '%s', got: %v", c.testCase, err)
 		}
-	}
-	newMockTransport(resp, 0, nil)
-	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-	err = Search4Services(cer, &testSys)
-	if err == nil {
-		t.Errorf("Expected errors")
-	}
-
-	// Bad case: Unpack() returns an error and type assertion/conversion fails
-	resp = func() *http.Response {
-		return &http.Response{
-			Status:     "200 OK",
-			StatusCode: 200,
-			Header:     http.Header{"Content-Type": []string{"Error"}},
-			Body:       io.NopCloser(strings.NewReader(string(data))),
+		if (c.expectError == true) && (err == nil) {
+			t.Errorf("Expected errors in '%s'", c.testCase)
 		}
 	}
-	newMockTransport(resp, 0, nil)
-	cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-	err = Search4Services(cer, &testSys)
-	if err == nil {
-		t.Errorf("Expected errors")
-	}
 }
 
 func createTestServiceRecord(number int) (f forms.ServiceRecord_v1) {
@@ -457,6 +472,15 @@ func TestFillDiscoveredServices(t *testing.T) {
 	}
 }
 
+// --------------------------------------------------------------- //
+// Helper functions and structs for testing ExtractDiscoveryForm()
+// --------------------------------------------------------------- //
+
+type extractDiscoveryFormParams struct {
+	expectError bool
+	testCase string
+}
+
 // ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err error)
 func TestExtractDiscoveryForm(t *testing.T) {
 	// Best case: everything passes

From b3b88ce7052f6b3ea2e02c625691a6df0486e6eb Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Wed, 9 Jul 2025 15:03:36 +0200
Subject: [PATCH 152/186] service_discovery_test.go converted to table driven
 tests

---
 usecases/service_discovery_test.go | 101 +++++++++++++++--------------
 1 file changed, 53 insertions(+), 48 deletions(-)

diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index 4b8b9d9..608283f 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -478,59 +478,64 @@ func TestFillDiscoveredServices(t *testing.T) {
 
 type extractDiscoveryFormParams struct {
 	expectError bool
-	testCase string
+	data        func() any
+	testCase    string
 }
 
 // ExtractDiscoveryForm(bodyBytes []byte) (sLoc forms.ServicePoint_v1, err error)
 func TestExtractDiscoveryForm(t *testing.T) {
-	// Best case: everything passes
-	spForm := createServicePointTestForm()
-	data, err := json.Marshal(spForm)
-	if err != nil {
-		t.Errorf("Error occurred while marshaling the test form")
-	}
-	//form version: forms.ServicePoint_v1 expected
-	form, err := ExtractDiscoveryForm(data)
-	if err != nil {
-		t.Errorf("Expected no errors")
-	}
-	if form.ServLocation != "TestService" {
-		t.Errorf("Expected service location: %s, got %s", "TestService", form.ServLocation)
-	}
-
-	// Bad case: Default switch case, wrong form version
-	spForm.Version = ""
-	data, err = json.Marshal(spForm)
-	if err != nil {
-		t.Errorf("Error occurred while marshaling the test form")
-	}
-	form, err = ExtractDiscoveryForm(data)
-	if err == nil {
-		t.Errorf("Expected error because of wrong form version")
-	}
-
-	// Bad case: version key not found
-	data, err = json.Marshal(nil)
-	if err != nil {
-		t.Errorf("Error when marshalling in test")
-	}
-	form, err = ExtractDiscoveryForm(data)
-	if err == nil {
-		t.Errorf("Expected errors for missing form")
+	params := []extractDiscoveryFormParams{
+		{
+			false,
+			func() any { return createServicePointTestForm() },
+			"Best case",
+		},
+		{
+			true,
+			func() any {
+				return ""
+			},
+			"Bad case, Unmarshal breaks",
+		},
+		{
+			true,
+			func() any {
+				form := createServicePointTestForm()
+				form.Version = ""
+				return form
+			},
+			"Bad case, wrong form version",
+		},
+		{
+			true,
+			func() any { return nil },
+			"Bad case, version key missing",
+		},
+		{
+			true,
+			func() any {
+				wrongForm := make(map[string]any)
+				wrongForm["version"] = "ServicePoint_v1"
+				wrongForm["serviceId"] = false // Target field is an int
+				return wrongForm
+			},
+			"Bad case, can't unmarshal to ServicePoint_v1 (field type mismatch)",
+		},
 	}
 
-	// Bad case: Unmarshalling body bytes to forms.ServicePoint_v1
-	// Needed to create my own map, with the correct version but a field that had a different type
-	// than the target field in order to break unmarshal
-	wrongForm := make(map[string]any)
-	wrongForm["version"] = "ServicePoint_v1"
-	wrongForm["serviceId"] = false // Target field is an int
-	data, err = json.Marshal(wrongForm)
-	if err != nil {
-		t.Errorf("Error when marshalling in test")
-	}
-	form, err = ExtractDiscoveryForm(data)
-	if err == nil {
-		t.Errorf("Expected errors for wrong form")
+	for _, c := range params {
+		// Setup
+		data, err := json.Marshal(c.data())
+		if err != nil {
+			t.Errorf("couldn't marshal data in '%s'", c.testCase)
+		}
+		// Test
+		_, err = ExtractDiscoveryForm(data)
+		if (c.expectError == false) && (err != nil) {
+			t.Errorf("Expected no errors in '%s', got: %v", c.testCase, err)
+		}
+		if (c.expectError == true) && (err == nil) {
+			t.Errorf("Expected errors in '%s'", c.testCase)
+		}
 	}
 }

From d068cdd935753322bb98dc53be604b884b4e64a4 Mon Sep 17 00:00:00 2001
From: walpat-1 <walpat-1@student.ltu.se>
Date: Wed, 9 Jul 2025 15:25:47 +0200
Subject: [PATCH 153/186] Removed unnecessary comments and tests

---
 usecases/configuration_test.go     | 92 +++++++++++++-----------------
 usecases/service_discovery_test.go |  1 -
 2 files changed, 39 insertions(+), 54 deletions(-)

diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index 7620746..f5592bc 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -207,9 +207,6 @@ func createConfigNoTraits(sys *components.System, assetAmount int) (err error) {
 	return
 }
 
-// This is the config in string form from the original Configure()
-var expectedConf string = `map[coreSystems:[map[coreSystem:serviceregistrar url:http://localhost:20102/serviceregistrar/registry] map[coreSystem:orchestrator url:http://localhost:20103/orchestrator/orchestration] map[coreSystem:ca url:http://localhost:20100/ca/certification] map[coreSystem:maitreD url:http://localhost:20101/maitreD/maitreD]] protocolsNports:map[coap:0 http:1234 https:0] systemname:testSystem unit_assets:[map[details:map[Test:[Test]] name:testUnitAsset services:[map[costUnit: definition:test details:map[Forms:[SignalA_v1a]] registrationPeriod:45 subpath:test]] traits:<nil>]]]`
-
 type setupDefConfigParams struct {
 	expectError bool
 	testCase    string
@@ -219,10 +216,21 @@ type setupDefConfigParams struct {
 
 func TestSetupDefaultConfig(t *testing.T) {
 	testParams := []setupDefConfigParams{
-		// {expectError, testCase, setup(), cleanup()}
-		{false, "Best case", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 1) }, func() (err error) { return cleanup() }},
-		{false, "Good case, asset has traits", func(sys *components.System) (err error) { return createConfigHasTraits(sys) }, func() (err error) { return cleanup() }},
-		{true, "No assets in sys", func(sys *components.System) (err error) { return createConfigHasTraits(sys) }, func() (err error) { return cleanup() }},
+		{
+			false, "Best case",
+			func(sys *components.System) (err error) { return createConfigNoTraits(sys, 1) },
+			func() (err error) { return cleanup() },
+		},
+		{
+			false, "Good case, asset has traits",
+			func(sys *components.System) (err error) { return createConfigHasTraits(sys) },
+			func() (err error) { return cleanup() },
+		},
+		{
+			true, "No assets in sys",
+			func(sys *components.System) (err error) { return createConfigHasTraits(sys) },
+			func() (err error) { return cleanup() },
+		},
 	}
 
 	// Start of test
@@ -259,46 +267,6 @@ func TestSetupDefaultConfig(t *testing.T) {
 	}
 }
 
-// This test is to ensure that setupDefaultConfig() doesnt change the behaviour of of Config()
-func TestSetupDefaultConfigCorrectness(t *testing.T) {
-	testSys := createTestSystem(false)
-
-	// Setup a default config with setupDefaultConfig() func
-	defConf, err := setupDefaultConfig(&testSys)
-	if err != nil {
-		t.Errorf("error in setupDefaultConfig() in test: %v", err)
-	}
-
-	def, err := os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0600)
-	if err != nil {
-		t.Errorf("error while opening/creating systemconfig.json in test: %v", err)
-	}
-	defer def.Close()
-	// Write our defaultConfig to file with correct indent
-	enc := json.NewEncoder(def)
-	enc.SetIndent("", "     ")
-	err = enc.Encode(defConf)
-	if err != nil {
-		t.Errorf("Couldn't encode to 'systemconfig.json' in test: %v", err)
-	}
-
-	// Decode to defaultConfig so we can compare the created default- and expected config
-	var defaultConfig any
-	def.Seek(0, 0)
-	err = json.NewDecoder(def).Decode(&defaultConfig)
-	if err != nil {
-		t.Errorf("couldn't decode from 'systemconfig.json' in test: %v", err)
-	}
-	err = os.Remove("systemconfig.json")
-	if err != nil {
-		t.Errorf("couldn't remove 'systemconfig.json' in test: %v", err)
-	}
-	// Check if defaultConfig converted to a string is the same as the expectedConf
-	if fmt.Sprint(defaultConfig) != expectedConf {
-		t.Errorf("systemconfig not equal")
-	}
-}
-
 func cleanup() error {
 	return os.Remove("systemconfig.json")
 }
@@ -313,7 +281,11 @@ type configureParams struct {
 func TestConfigure(t *testing.T) {
 	testParams := []configureParams{
 		// {expectError, testCase, setup(), cleanup()}
-		{false, "Best case, one asset", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 1) }, func() (err error) { return cleanup() }},
+		{
+			false, "Best case, one asset",
+			func(sys *components.System) (err error) { return createConfigNoTraits(sys, 1) },
+			func() (err error) { return cleanup() },
+		},
 		{
 			true,
 			"Can't open/create config",
@@ -323,9 +295,21 @@ func TestConfigure(t *testing.T) {
 			},
 			func() (err error) { return cleanup() },
 		},
-		{true, "Config missing", func(sys *components.System) (err error) { return nil }, func() (err error) { return cleanup() }},
-		{false, "No Assets in config", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 0) }, func() (err error) { return cleanup() }},
-		{false, "Multiple Assets in config", func(sys *components.System) (err error) { return createConfigNoTraits(sys, 3) }, func() (err error) { return cleanup() }},
+		{
+			true, "Config missing",
+			func(sys *components.System) (err error) { return nil },
+			func() (err error) { return cleanup() },
+		},
+		{
+			false, "No Assets in config",
+			func(sys *components.System) (err error) { return createConfigNoTraits(sys, 0) },
+			func() (err error) { return cleanup() },
+		},
+		{
+			false, "Multiple Assets in config",
+			func(sys *components.System) (err error) { return createConfigNoTraits(sys, 3) },
+			func() (err error) { return cleanup() },
+		},
 		{
 			true,
 			"No assets in sys",
@@ -389,7 +373,8 @@ func TestGetServiceList(t *testing.T) {
 	}
 	servList := getServicesList(mua)
 	if len(servList) != 1 && servList[0].Definition != "test" {
-		t.Errorf("Expected length: 1, got %d\tExpected 'Definition': test, got %s", len(servList), servList[0].Definition)
+		t.Errorf("Expected length: 1, got %d\tExpected 'Definition': test, got %s",
+			len(servList), servList[0].Definition)
 	}
 }
 
@@ -412,7 +397,8 @@ func TestMakeServiceMap(t *testing.T) {
 	for c := range 6 {
 		service := fmt.Sprintf("test%d", c)
 		if servMap[service].SubPath != service || servMap[service].ID != c {
-			t.Errorf(`Expected servMap["%s"].SubPath to be "%s", with ID: "%d". Got Subpath: "%s", with ID: "%d"`, service, service, c, servMap[service].SubPath, servMap[service].ID)
+			t.Errorf(`Expected servMap["%s"].SubPath to be "%s", with ID: "%d". Got Subpath: "%s", with ID: "%d"`,
+				service, service, c, servMap[service].SubPath, servMap[service].ID)
 		}
 	}
 }
diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index 608283f..0103d27 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -256,7 +256,6 @@ func createMultiHttpResp(statusCode int, broken bool, allowedReads int) func() *
 func TestSearch4Service(t *testing.T) {
 	// Test parameters
 	params := []search4ServiceParams{
-		//{ expectError, response, transport, testCase }
 		{
 			false,
 			createMultiHttpResp(200, false, 0),

From b2d0e404cf233c3eeaaf9445af32a35a62af0408 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 10 Jul 2025 11:03:53 +0200
Subject: [PATCH 154/186] Removed unnecessary code & comments

---
 usecases/configuration_test.go | 130 +++++++++++++++++----------------
 1 file changed, 66 insertions(+), 64 deletions(-)

diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index f5592bc..7ea4c20 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -43,6 +43,11 @@ func (mua mockUnitAssetWithTraits) GetDetails() map[string][]string {
 func (mua mockUnitAssetWithTraits) Serving(w http.ResponseWriter, r *http.Request, servicePath string) {
 }
 
+// --------------------------------------------------------- //
+// Helpfunctions that creates a default config file
+// with/without any asset traits
+// --------------------------------------------------------- //
+
 func createConfigHasTraits(sys *components.System) (err error) {
 	var defaultConfig templateOut
 
@@ -92,7 +97,7 @@ func createConfigHasTraits(sys *components.System) (err error) {
 			}
 		}
 	}
-	defaultConfig.Assets = []ConfigurableAsset{confAsset} // this is a list of unit assets
+	defaultConfig.Assets = []ConfigurableAsset{confAsset}
 
 	leadingRegistrar := components.CoreSystem{
 		Name: "serviceregistrar",
@@ -120,9 +125,9 @@ func createConfigHasTraits(sys *components.System) (err error) {
 	}
 	defer defaultConfigFile.Close()
 
-	enc := json.NewEncoder(defaultConfigFile) // Create an encoder that allows writing to a file
+	enc := json.NewEncoder(defaultConfigFile)
 	enc.SetIndent("", "     ")
-	err = enc.Encode(defaultConfig) // Write defaultConfig template to file
+	err = enc.Encode(defaultConfig)
 	if err != nil {
 		return fmt.Errorf("jsonEncode: %v", err)
 	}
@@ -132,11 +137,11 @@ func createConfigHasTraits(sys *components.System) (err error) {
 func createConfigNoTraits(sys *components.System, assetAmount int) (err error) {
 	var defaultConfig templateOut
 
-	if assetAmount == 1 {
+	for x := range assetAmount {
 		setTest := components.Service{
-			ID:            1,
-			Definition:    "test",
-			SubPath:       "test",
+			ID:            x,
+			Definition:    fmt.Sprintf("test%d", x),
+			SubPath:       fmt.Sprintf("test%d", x),
 			Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
 			Description:   "A test service",
 			RegPeriod:     45,
@@ -145,31 +150,11 @@ func createConfigNoTraits(sys *components.System, assetAmount int) (err error) {
 		}
 		servList := []components.Service{setTest}
 		mua := ConfigurableAsset{
-			Name:     "testUnitAsset",
+			Name:     fmt.Sprintf("testUnitAsset%d", x),
 			Details:  map[string][]string{"Test": {"Test"}},
 			Services: servList,
 		}
 		defaultConfig.Assets = append(defaultConfig.Assets, mua)
-	} else {
-		for x := range assetAmount {
-			setTest := components.Service{
-				ID:            x,
-				Definition:    fmt.Sprintf("test%d", x),
-				SubPath:       fmt.Sprintf("test%d", x),
-				Details:       map[string][]string{"Forms": {"SignalA_v1a"}},
-				Description:   "A test service",
-				RegPeriod:     45,
-				RegTimestamp:  "now",
-				RegExpiration: "45",
-			}
-			servList := []components.Service{setTest}
-			mua := ConfigurableAsset{
-				Name:     fmt.Sprintf("testUnitAsset%d", x),
-				Details:  map[string][]string{"Test": {"Test"}},
-				Services: servList,
-			}
-			defaultConfig.Assets = append(defaultConfig.Assets, mua)
-		}
 	}
 
 	leadingRegistrar := components.CoreSystem{
@@ -198,38 +183,49 @@ func createConfigNoTraits(sys *components.System, assetAmount int) (err error) {
 	}
 	defer defaultConfigFile.Close()
 
-	enc := json.NewEncoder(defaultConfigFile) // Create an encoder that allows writing to a file
+	enc := json.NewEncoder(defaultConfigFile)
 	enc.SetIndent("", "     ")
-	err = enc.Encode(defaultConfig) // Write defaultConfig template to file
+	err = enc.Encode(defaultConfig)
 	if err != nil {
 		return fmt.Errorf("jsonEncode: %v", err)
 	}
 	return
 }
 
+// --------------------------------------------------------- //
+// Helpfunctions and structs for testing SetupDefaultConfig()
+// --------------------------------------------------------- //
+
+func cleanup() error {
+	return os.Remove("systemconfig.json")
+}
+
 type setupDefConfigParams struct {
 	expectError bool
-	testCase    string
 	setup       func(*components.System) (err error)
 	cleanup     func() (err error)
+	testCase    string
 }
 
 func TestSetupDefaultConfig(t *testing.T) {
 	testParams := []setupDefConfigParams{
 		{
-			false, "Best case",
+			false,
 			func(sys *components.System) (err error) { return createConfigNoTraits(sys, 1) },
 			func() (err error) { return cleanup() },
+			"Best case",
 		},
 		{
-			false, "Good case, asset has traits",
+			false,
 			func(sys *components.System) (err error) { return createConfigHasTraits(sys) },
 			func() (err error) { return cleanup() },
+			"Good case, asset has traits",
 		},
 		{
-			true, "No assets in sys",
+			true,
 			func(sys *components.System) (err error) { return createConfigHasTraits(sys) },
 			func() (err error) { return cleanup() },
+			"No assets in sys",
 		},
 	}
 
@@ -249,14 +245,11 @@ func TestSetupDefaultConfig(t *testing.T) {
 
 		// Test
 		_, err = setupDefaultConfig(&testSys)
-		if c.expectError != true {
-			if err != nil {
-				t.Errorf("Expected no errors in testcase '%s', got: %v", c.testCase, err)
-			}
-		} else {
-			if err == nil {
-				t.Errorf("expected errors in testcase '%s', got none", c.testCase)
-			}
+		if c.expectError == false && err != nil {
+			t.Errorf("Expected no errors in testcase '%s', got: %v", c.testCase, err)
+		}
+		if c.expectError == true && err == nil {
+			t.Errorf("expected errors in testcase '%s', got none", c.testCase)
 		}
 
 		// Cleanup
@@ -267,57 +260,61 @@ func TestSetupDefaultConfig(t *testing.T) {
 	}
 }
 
-func cleanup() error {
-	return os.Remove("systemconfig.json")
-}
+// --------------------------------------------------------- //
+// Helpfunctions and structs for testing Configure()
+// --------------------------------------------------------- //
 
 type configureParams struct {
 	expectError bool
-	testCase    string
-	setup       func(*components.System) (err error)
-	cleanup     func() (err error)
+
+	setup    func(*components.System) (err error)
+	cleanup  func() (err error)
+	testCase string
 }
 
 func TestConfigure(t *testing.T) {
 	testParams := []configureParams{
-		// {expectError, testCase, setup(), cleanup()}
 		{
-			false, "Best case, one asset",
+			false,
 			func(sys *components.System) (err error) { return createConfigNoTraits(sys, 1) },
 			func() (err error) { return cleanup() },
+			"Best case, one asset",
 		},
 		{
 			true,
-			"Can't open/create config",
 			func(sys *components.System) (err error) {
 				_, err = os.OpenFile("systemconfig.json", os.O_RDWR|os.O_CREATE, 0000)
 				return
 			},
 			func() (err error) { return cleanup() },
+			"Can't open/create config",
 		},
 		{
-			true, "Config missing",
+			true,
 			func(sys *components.System) (err error) { return nil },
 			func() (err error) { return cleanup() },
+			"Config missing",
 		},
 		{
-			false, "No Assets in config",
+			false,
 			func(sys *components.System) (err error) { return createConfigNoTraits(sys, 0) },
 			func() (err error) { return cleanup() },
+			"No Assets in config",
 		},
 		{
-			false, "Multiple Assets in config",
+			false,
 			func(sys *components.System) (err error) { return createConfigNoTraits(sys, 3) },
 			func() (err error) { return cleanup() },
+			"Multiple Assets in config",
 		},
 		{
 			true,
-			"No assets in sys",
 			func(sys *components.System) (err error) {
 				sys.UAssets = nil
 				return createConfigNoTraits(sys, 1)
 			},
 			func() (err error) { return cleanup() },
+			"No assets in sys",
 		},
 	}
 
@@ -333,14 +330,11 @@ func TestConfigure(t *testing.T) {
 
 		// Test
 		_, err = Configure(&testSys)
-		if testCase.expectError == false {
-			if err != nil {
-				t.Errorf("Expected no errors in '%s', got: %v", testCase.testCase, err)
-			}
-		} else {
-			if err == nil {
-				t.Errorf("Expected errors in testcase '%s' got none", testCase.testCase)
-			}
+		if testCase.expectError == false && err != nil {
+			t.Errorf("Expected no errors in '%s', got: %v", testCase.testCase, err)
+		}
+		if testCase.expectError == true && err == nil {
+			t.Errorf("Expected errors in testcase '%s'", testCase.testCase)
 		}
 
 		//Cleanup
@@ -351,6 +345,10 @@ func TestConfigure(t *testing.T) {
 	}
 }
 
+// --------------------------------------------------------- //
+// Testing GetServiceList()
+// --------------------------------------------------------- //
+
 func TestGetServiceList(t *testing.T) {
 	setTest := &components.Service{
 		ID:            1,
@@ -378,6 +376,10 @@ func TestGetServiceList(t *testing.T) {
 	}
 }
 
+// --------------------------------------------------------- //
+// Testing MakeServiceMap()
+// --------------------------------------------------------- //
+
 func TestMakeServiceMap(t *testing.T) {
 	var servList []components.Service
 	for x := range 6 {
@@ -397,7 +399,7 @@ func TestMakeServiceMap(t *testing.T) {
 	for c := range 6 {
 		service := fmt.Sprintf("test%d", c)
 		if servMap[service].SubPath != service || servMap[service].ID != c {
-			t.Errorf(`Expected servMap["%s"].SubPath to be "%s", with ID: "%d". Got Subpath: "%s", with ID: "%d"`,
+			t.Errorf(`Expected servMap["%s"].SubPath to be "%s", with ID: "%d". Got: "%s", with ID: "%d"`,
 				service, service, c, servMap[service].SubPath, servMap[service].ID)
 		}
 	}

From 7a702ce8d27a45929b6070a6ef8276d7ac0518d1 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 10 Jul 2025 11:08:57 +0200
Subject: [PATCH 155/186] Simplified logic, removed unnecessary tests and
 slightly changed param structs

---
 usecases/service_discovery_test.go | 95 ++++++++----------------------
 1 file changed, 25 insertions(+), 70 deletions(-)

diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index 0103d27..d049a24 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -15,30 +15,6 @@ import (
 	"github.com/sdoque/mbaigo/forms"
 )
 
-// Tests the output from ServQuestForms() to ensure expected outcome
-func TestServQuestForms(t *testing.T) {
-	expectedForms := []string{"ServiceQuest_v1", "ServicePoint_v1"}
-	lst := ServQuestForms()
-	// Loop through the forms from ServQuestForms() and compare them to expected forms
-	for i, form := range lst {
-		if form != expectedForms[i] {
-			t.Errorf("Expected %s, got %s", form, expectedForms[i])
-		}
-	}
-}
-
-func TestFillQuestForm(t *testing.T) {
-	testSys := createTestSystem(false)
-	mua := mockUnitAsset{}
-	questForm := FillQuestForm(&testSys, mua, "TestDef", "TestProtocol")
-	// Loop through the details in questForm and mua (mockUnitAsset), error if they're not the same
-	for i, detail := range questForm.Details["Details"] {
-		if detail != mua.GetDetails()["Details"][i] {
-			t.Errorf("Expected %s, got: %s", mua.GetDetails()["Details"][i], detail)
-		}
-	}
-}
-
 type testBodyHasProtocol struct {
 	Version  string `json:"version"`
 	Protocol int    `json:"protocol"`
@@ -50,15 +26,6 @@ type testBodyHasVersion struct {
 
 type testBodyNoVersion struct{}
 
-type extractQuestFormParams struct {
-	testCase      string
-	expectedError bool
-	proto         int
-	version       string
-	errRead       bool
-	f             func(int, string, bool) ([]byte, error)
-}
-
 func createTestBodyHasProtocol(proto int, version string, errRead bool) ([]byte, error) {
 	if errRead == true {
 		return json.Marshal(errReader(0))
@@ -67,11 +34,7 @@ func createTestBodyHasProtocol(proto int, version string, errRead bool) ([]byte,
 		Protocol: proto,
 		Version:  version,
 	}
-	data, err := json.Marshal(body)
-	if err != nil {
-		return nil, err
-	}
-	return data, nil
+	return json.Marshal(body)
 }
 
 func createTestBodyHasVersion(proto int, version string, errRead bool) ([]byte, error) {
@@ -80,12 +43,8 @@ func createTestBodyHasVersion(proto int, version string, errRead bool) ([]byte,
 	}
 	body := testBodyHasVersion{
 		Version: version,
-	}
-	data, err := json.Marshal(body)
-	if err != nil {
-		return nil, err
-	}
-	return data, nil
+	}	
+	return json.Marshal(body)
 }
 
 func createTestBodyHasNoVersion(proto int, version string, errRead bool) ([]byte, error) {
@@ -93,43 +52,39 @@ func createTestBodyHasNoVersion(proto int, version string, errRead bool) ([]byte
 		return json.Marshal(errReader(0))
 	}
 	body := testBodyNoVersion{}
-	data, err := json.Marshal(body)
-	if err != nil {
-		return nil, err
-	}
-	return data, nil
+	return json.Marshal(body)
+}
+
+type extractQuestFormParams struct {
+	expectedError bool
+	errRead       bool
+	proto         int
+	version       string
+	f             func(int, string, bool) ([]byte, error)
+	testCase      string
 }
 
 func TestExtractQuestForm(t *testing.T) {
-	// A list holding structs containing the parameters used for the test
 	testParams := []extractQuestFormParams{
-		// Always start with the "Best case, no errors"
-		// {testCase, expectedError, proto, version, errRead, data}
-		{"No errors", false, -1, "ServiceQuest_v1", false, createTestBodyHasVersion},
-		{"Error during Unmarshal", true, -1, "ServiceQuest_v1", true, createTestBodyHasVersion},
-		{"Missing version", false, -1, "", false, createTestBodyHasNoVersion},
-		{"Error while writing to correct form", true, 123, "ServiceQuest_v1", false, createTestBodyHasProtocol},
-		{"Error Unsupported version", true, -1, "", false, createTestBodyHasVersion},
+		{false, false, -1, "ServiceQuest_v1", createTestBodyHasVersion, "No errors"},
+		{true, true, -1, "ServiceQuest_v1", createTestBodyHasVersion, "Error during Unmarshal"},
+		{true, false, -1, "", createTestBodyHasNoVersion, "Missing version"},
+		{true, false, 123, "ServiceQuest_v1", createTestBodyHasProtocol, "Error while writing to correct form"},
+		{true, false, -1, "", createTestBodyHasVersion, "Error Unsupported version"},
 	}
 	for _, x := range testParams {
-		// Create the data []byte that will be sent into the function
 		data, err := x.f(x.proto, x.version, x.errRead)
 		if err != nil {
 			t.Errorf("---\tError occurred while creating test data")
 		}
 		// Do the test
-		rec, err := ExtractQuestForm(data)
-		if x.testCase == "No errors" {
-			if err != nil {
-				t.Errorf("Test case: '%s' got error: %v", x.testCase, err)
-			}
-			if x.testCase == "Missing version" && rec.Version != "" {
-				t.Errorf("---\tExpected no version, got %s", rec.Version)
-			}
-		} else {
-			if err == nil {
-				t.Errorf("---\tTest case: Expected errors in '%s', got none", x.testCase)
-			}
+		_, err = ExtractQuestForm(data)
+		if x.expectedError == false && err != nil {
+			t.Errorf("Expected no errors in '%s', got: %v ", x.testCase, err)
+		}
+		if x.expectedError == true && err == nil {
+			t.Errorf("Expected errors in '%s'", x.testCase)
+
 		}
 	}
 }

From a161b3c517b8d154e73178cf2d00547a716db85f Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 10 Jul 2025 11:12:19 +0200
Subject: [PATCH 156/186] gofmt'ed the code

---
 usecases/service_discovery_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index d049a24..7bcc9bf 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -43,7 +43,7 @@ func createTestBodyHasVersion(proto int, version string, errRead bool) ([]byte,
 	}
 	body := testBodyHasVersion{
 		Version: version,
-	}	
+	}
 	return json.Marshal(body)
 }
 

From 654db206af64dbfddf1bd88e07ccef13822c089b Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 10 Jul 2025 12:59:45 +0200
Subject: [PATCH 157/186] Fixed PR comment, 2 error checks simplified

---
 usecases/service_discovery_test.go | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index 7bcc9bf..d7a412e 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -157,14 +157,11 @@ func TestSendHttpReq(t *testing.T) {
 		}
 		// Run the test
 		_, err = sendHttpReq(c.method, c.url, c.data)
-		if c.expectError == false {
-			if err != nil {
-				t.Errorf("Unexpected error in '%s' test case: %e", c.testCase, err)
-			}
-		} else {
-			if err == nil {
-				t.Errorf("Expected error in '%s' test case, got none", c.testCase)
-			}
+		if c.expectError == false && err != nil {
+			t.Errorf("Unexpected error in '%s' test case: %e", c.testCase, err)
+		}
+		if c.expectError == true && err == nil {
+			t.Errorf("Expected error in '%s' test case, got none", c.testCase)
 		}
 	}
 }
@@ -414,14 +411,11 @@ func TestFillDiscoveredServices(t *testing.T) {
 	versionList := []string{"ServiceRecordList_v1", "default"}
 	for _, version := range versionList {
 		_, err := FillDiscoveredServices(dsList, version)
-		if version != "ServiceRecordList_v1" {
-			if err == nil {
-				t.Errorf("Expected error in default case")
-			}
-		} else {
-			if err != nil {
-				t.Errorf("Unexpected error during testing: %v", err)
-			}
+		if version != "ServiceRecordList_v1" && err == nil {
+			t.Errorf("Expected error in default case")
+		}
+		if version == "ServiceRecordList_v1" && err != nil {
+			t.Errorf("Unexpected error during testing: %v", err)
 		}
 	}
 }

From 48dbcf0b5504a13e6bee6ba0938e272aefd3fa02 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Thu, 10 Jul 2025 13:36:07 +0200
Subject: [PATCH 158/186] Added comment explaining a helpfunction in test

---
 usecases/configuration_test.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/usecases/configuration_test.go b/usecases/configuration_test.go
index 7ea4c20..6a5d55f 100644
--- a/usecases/configuration_test.go
+++ b/usecases/configuration_test.go
@@ -48,6 +48,8 @@ func (mua mockUnitAssetWithTraits) Serving(w http.ResponseWriter, r *http.Reques
 // with/without any asset traits
 // --------------------------------------------------------- //
 
+// This is pretty much a copy of setupDefaultConfig() in configuration.go,
+// but this also creates and writes to a systemconfig.json file
 func createConfigHasTraits(sys *components.System) (err error) {
 	var defaultConfig templateOut
 
@@ -86,6 +88,7 @@ func createConfigHasTraits(sys *components.System) (err error) {
 	}
 	var muaInterface components.UnitAsset = mua
 	sys.UAssets[mua.GetName()] = &muaInterface
+
 	// If the asset exposes traits, serialize them and store as raw JSON
 	if assetWithTraits, ok := assetTemplate.(components.HasTraits); ok {
 		if traits := assetWithTraits.GetTraits(); traits != nil {
@@ -134,6 +137,8 @@ func createConfigHasTraits(sys *components.System) (err error) {
 	return
 }
 
+// This is pretty much a copy of setupDefaultConfig() in configuration.go,
+// but this also creates and writes to a systemconfig.json file
 func createConfigNoTraits(sys *components.System, assetAmount int) (err error) {
 	var defaultConfig templateOut
 

From 0b3b26b79ac70207f274c6152d9692586fa5eec0 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 10 Jul 2025 13:49:41 +0200
Subject: [PATCH 159/186] fixes faulty test cases causing linter errors

---
 usecases/service_discovery_test.go | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index d7a412e..c663a23 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -269,7 +269,7 @@ func TestSearch4Services(t *testing.T) {
 			false,
 			func() (cer *components.Cervice, sys components.System) {
 				sys = createTestSystem(false)
-				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 				return
 			},
 			createMultiHttpResp(200, false, 0),
@@ -280,7 +280,7 @@ func TestSearch4Services(t *testing.T) {
 			true,
 			func() (cer *components.Cervice, sys components.System) {
 				sys = createTestSystem(false)
-				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 				return
 			},
 			createMultiHttpResp(200, false, 0),
@@ -296,7 +296,7 @@ func TestSearch4Services(t *testing.T) {
 						(*sys.CoreS[i]).Url = ""
 					}
 				}
-				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 				return
 			},
 			createMultiHttpResp(200, false, 0),
@@ -307,7 +307,7 @@ func TestSearch4Services(t *testing.T) {
 			true,
 			func() (cer *components.Cervice, sys components.System) {
 				sys = createTestSystem(false)
-				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 				return
 			},
 			createMultiHttpResp(200, false, 0),
@@ -318,7 +318,7 @@ func TestSearch4Services(t *testing.T) {
 			true,
 			func() (cer *components.Cervice, sys components.System) {
 				sys = createTestSystem(false)
-				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 				return
 			},
 			createMultiHttpResp(200, true, 2),
@@ -329,7 +329,7 @@ func TestSearch4Services(t *testing.T) {
 			true,
 			func() (cer *components.Cervice, sys components.System) {
 				sys = createTestSystem(false)
-				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 				return
 			},
 			func() *http.Response {
@@ -347,7 +347,7 @@ func TestSearch4Services(t *testing.T) {
 			true,
 			func() (cer *components.Cervice, sys components.System) {
 				sys = createTestSystem(false)
-				cer = (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 				return
 			},
 			func() *http.Response {

From fdf79cd9397c24efcca68f68abe5ce8d50eed73a Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 9 Jul 2025 09:22:51 +0200
Subject: [PATCH 160/186] Avoids re-registering the messenger

---
 usecases/provision.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/usecases/provision.go b/usecases/provision.go
index 7dd582b..88d19ae 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -124,6 +124,11 @@ func getBestContentType(acceptHeader string) string {
 }
 
 func RegisterMessenger(w http.ResponseWriter, r *http.Request, s *components.System) {
+	if r.Method != "POST" {
+		http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
+		return
+	}
+
 	b, err := io.ReadAll(r.Body)
 	if err != nil {
 		log.Printf("read request body: %v\n", err)
@@ -132,6 +137,7 @@ func RegisterMessenger(w http.ResponseWriter, r *http.Request, s *components.Sys
 		return
 	}
 	defer r.Body.Close()
+
 	f, err := Unpack(b, r.Header.Get("Content-Type"))
 	if err != nil {
 		log.Printf("unpack: %v\n", err)
@@ -144,5 +150,10 @@ func RegisterMessenger(w http.ResponseWriter, r *http.Request, s *components.Sys
 		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 		return
 	}
+	if _, found := s.Messengers.Load(reg.Host); found {
+		// The system already knows the messenger, avoid re-storing it so that
+		// the error count don't get reset
+		return
+	}
 	s.Messengers.Store(reg.Host, 0) // Registers the host with 0 errors
 }

From 1590c13ca78ab9e9762634db0ae610ebdb3bcf6f Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 9 Jul 2025 09:22:51 +0200
Subject: [PATCH 161/186] Adds initial Log func for sending msgs to the
 messenger

---
 usecases/consumption.go | 53 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index edf1e59..0206fbe 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -22,8 +22,10 @@ package usecases
 import (
 	"fmt"
 	"io"
+	"log"
 
 	"net/http"
+	"net/url"
 
 	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
@@ -76,3 +78,54 @@ func stateHandler(httpMethod string, cer *components.Cervice, sys *components.Sy
 	headerContentType := resp.Header.Get("Content-Type")
 	return Unpack(bodyBytes, headerContentType)
 }
+
+const messengerMaxErrors int = 3
+
+func Log(sys *components.System, lvl forms.MessageLevel, msg string, args ...any) {
+	sm := forms.NewSystemMessage_v1(lvl, fmt.Sprintf(msg+"\n", args...), sys.Name)
+	body, err := Pack(forms.Form(&sm), "application/json")
+	if err != nil {
+		log.Print(sm.Body)
+		log.Printf("failed to pack SystemMessage: %v\n", err)
+		return
+	}
+
+	// Iterate over all messengers and try sending a copy of the log msg
+	// (can't use a regular for-loop for this type)
+	sys.Messengers.Range(func(k, v any) bool {
+		host, ok1 := k.(string) // Should always be a host string!
+		errors, ok2 := v.(int)
+		if !ok1 || !ok2 {
+			sys.Messengers.Delete(k) // if not, removes the unusable cruft
+			return true
+		}
+
+		newErrors := 0 // If there's no error while sending msg, the count is reset
+		if err := sendLogMessage(host, body); err != nil {
+			if errors >= messengerMaxErrors {
+				// Too many errors indicates a problematic messenger
+				sys.Messengers.Delete(k)
+				return true
+			}
+			newErrors = errors + 1
+		}
+		sys.Messengers.Store(k, newErrors)
+		return true
+	})
+}
+
+// Hard-coding the path is ugly but it skips an extra service discovery cycle for now
+const messengerPath string = "/messenger/log/message"
+
+func sendLogMessage(h string, b []byte) error {
+	u, err := url.Parse("http://" + h + messengerPath)
+	if err != nil {
+		return err
+	}
+	resp, err := sendHTTPReq("POST", u.String(), b)
+	if err != nil {
+		return err
+	}
+	_ = resp.Body.Close() // Don't care about the body or any errors it might cause
+	return nil
+}

From 31655f467b96e81df52c536b42b4ce435d781fcf Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 11 Jul 2025 13:07:06 +0200
Subject: [PATCH 162/186] Ignores network errors from unregisterService()

---
 usecases/registration.go | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index 31028a6..a4202ad 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -187,14 +187,16 @@ func unregisterService(registrar string, serv *components.Service) error {
 	if registrar == "" {
 		return nil // there is no need to deregister if there is no leading registrar
 	}
-	unregisterURL := registrar + "/unregister/" + strconv.Itoa(serv.ID)
-	req, err := http.NewRequest("DELETE", unregisterURL, nil) // create a new request using http
+	u := registrar + "/unregister/" + strconv.Itoa(serv.ID)
+	req, err := http.NewRequest("DELETE", u, nil)
 	if err != nil {
 		return err
 	}
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return err
+		// Can't do anything about network errors. Don't care much either,
+		// since this system is shutting down. Ignorering this error for now.
+		return nil
 	}
 	defer resp.Body.Close()
 	return nil

From c9208cfb39c3d189cbd0531c2ec8ab1a3108d6fd Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 11 Jul 2025 13:23:11 +0200
Subject: [PATCH 163/186] Fixes test that expected network error from
 unregisterService

---
 usecases/registration_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/registration_test.go b/usecases/registration_test.go
index 3606ee8..2b7b314 100644
--- a/usecases/registration_test.go
+++ b/usecases/registration_test.go
@@ -166,8 +166,8 @@ type unregisterServiceTestStruct struct {
 var unregisterServiceTestParams = []unregisterServiceTestStruct{
 	{"https://leadingregistrar", false, 0, nil, "Good case, an unregistered service tries to unregister"},
 	{"https://leadingregistrar", false, 0, nil, "Good case, an registered service tries to unregister"},
-	{"https://leadingregistrar", true, 1, errHTTP, "Bad case, error in response body"},
 	{"", false, 0, nil, "Good case, no leading registrar URL was sent in"},
+	{"https://leadingregistrar", false, 1, errHTTP, "Bad case, empty error from response body"},
 	{brokenUrl, true, 0, nil, "Bad case, broken URL"},
 }
 

From 2135f082d689710c61940c422168759f1bd4ffb2 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 11 Jul 2025 14:10:28 +0200
Subject: [PATCH 164/186] Fixes defaulting to a too large delay during
 reregistration

---
 usecases/registration.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/usecases/registration.go b/usecases/registration.go
index a4202ad..2cb40d2 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -176,8 +176,9 @@ func registerService(sys *components.System, registrar string, ua *components.Un
 	}
 	// should not wait until the deadline to start to confirm live status
 	delay = time.Until(parsedTime.Add(-5 * time.Second))
-	if delay < 30*time.Second {
-		delay = 30 * time.Second
+	if delay < 1*time.Second {
+		// Avoid using zero/negative delays
+		delay = 1 * time.Second
 	}
 	return
 }

From f282dbaf7aa762a33d91240dc21a905aef39f99a Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 11 Jul 2025 15:31:17 +0200
Subject: [PATCH 165/186] Simplifies logging

---
 forms/message_forms.go  | 18 ++++++++++++++++++
 usecases/consumption.go | 37 +++++++++++++++++++++++++++----------
 2 files changed, 45 insertions(+), 10 deletions(-)

diff --git a/forms/message_forms.go b/forms/message_forms.go
index db0cc26..58d2ada 100644
--- a/forms/message_forms.go
+++ b/forms/message_forms.go
@@ -1,6 +1,7 @@
 package forms
 
 import (
+	"fmt"
 	"reflect"
 )
 
@@ -66,6 +67,23 @@ func NewSystemMessage_v1(l MessageLevel, b string, s string) SystemMessage_v1 {
 	}
 }
 
+func (f SystemMessage_v1) String() string {
+	var lvl string
+	switch f.Level {
+	case LevelDebug:
+		lvl = "DEBUG"
+	case LevelInfo:
+		lvl = "INFO"
+	case LevelWarn:
+		lvl = "WARN"
+	case LevelError:
+		lvl = "ERROR"
+	default:
+		lvl = "UNKNOWN"
+	}
+	return fmt.Sprintf("%s %s", lvl, f.Body)
+}
+
 // NewForm resets the form and defaults to using LevelInfo.
 func (f *SystemMessage_v1) NewForm() Form {
 	new := NewSystemMessage_v1(LevelInfo, "", "")
diff --git a/usecases/consumption.go b/usecases/consumption.go
index 0206fbe..22101f7 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -43,7 +43,7 @@ func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte)
 
 func stateHandler(httpMethod string, cer *components.Cervice, sys *components.System, bodyBytes []byte) (f forms.Form, err error) {
 	if len(cer.Nodes) == 0 {
-		err := Search4Services(cer, sys)
+		err = Search4Services(cer, sys)
 		if err != nil {
 			return f, err
 		}
@@ -81,11 +81,28 @@ func stateHandler(httpMethod string, cer *components.Cervice, sys *components.Sy
 
 const messengerMaxErrors int = 3
 
+func LogDebug(sys *components.System, msg string, args ...any) {
+	Log(sys, forms.LevelDebug, msg, args...)
+}
+
+func LogInfo(sys *components.System, msg string, args ...any) {
+	Log(sys, forms.LevelInfo, msg, args...)
+}
+
+func LogWarn(sys *components.System, msg string, args ...any) {
+	Log(sys, forms.LevelWarn, msg, args...)
+}
+
+func LogError(sys *components.System, msg string, args ...any) {
+	Log(sys, forms.LevelError, msg, args...)
+}
+
 func Log(sys *components.System, lvl forms.MessageLevel, msg string, args ...any) {
-	sm := forms.NewSystemMessage_v1(lvl, fmt.Sprintf(msg+"\n", args...), sys.Name)
+	sm := forms.NewSystemMessage_v1(lvl, fmt.Sprintf(msg, args...), sys.Name)
+	log.Println(sm.String()) // Always print the msg locally
+
 	body, err := Pack(forms.Form(&sm), "application/json")
 	if err != nil {
-		log.Print(sm.Body)
 		log.Printf("failed to pack SystemMessage: %v\n", err)
 		return
 	}
@@ -94,21 +111,21 @@ func Log(sys *components.System, lvl forms.MessageLevel, msg string, args ...any
 	// (can't use a regular for-loop for this type)
 	sys.Messengers.Range(func(k, v any) bool {
 		host, ok1 := k.(string) // Should always be a host string!
-		errors, ok2 := v.(int)
+		errors, ok2 := v.(int)  // and an error count
 		if !ok1 || !ok2 {
 			sys.Messengers.Delete(k) // if not, removes the unusable cruft
-			return true
+			return true              // and continue iterating
 		}
 
 		newErrors := 0 // If there's no error while sending msg, the count is reset
 		if err := sendLogMessage(host, body); err != nil {
-			if errors >= messengerMaxErrors {
-				// Too many errors indicates a problematic messenger
-				sys.Messengers.Delete(k)
-				return true
-			}
 			newErrors = errors + 1
 		}
+		if newErrors >= messengerMaxErrors {
+			// Too many errors indicates a problematic messenger
+			sys.Messengers.Delete(k)
+			return true
+		}
 		sys.Messengers.Store(k, newErrors)
 		return true
 	})

From c2dd2146937b61c363a39f2b9f270f2776be9fe3 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Mon, 14 Jul 2025 14:50:57 +0200
Subject: [PATCH 166/186] Redo registration upon bad responses from the
 registrar

---
 usecases/registration.go | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/usecases/registration.go b/usecases/registration.go
index 2cb40d2..1c50443 100644
--- a/usecases/registration.go
+++ b/usecases/registration.go
@@ -142,6 +142,12 @@ func registerService(sys *components.System, registrar string, ua *components.Un
 		return
 	}
 
+	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		err = fmt.Errorf("bad registration response: %s", resp.Status)
+		serv.ID = 0
+		return
+	}
+
 	// Handle response ------------------------------------------------
 
 	var b []byte

From 0108a5699c699501b485ae4ccaa984170083e054 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Mon, 14 Jul 2025 14:50:57 +0200
Subject: [PATCH 167/186] Refactors logging to not use the sync.Map and improve
 readability

---
 components/system.go    |  9 ++++++---
 usecases/consumption.go | 42 ++++++++++++++++++++---------------------
 usecases/provision.go   |  6 ++++--
 3 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/components/system.go b/components/system.go
index c9054d1..e226669 100644
--- a/components/system.go
+++ b/components/system.go
@@ -44,7 +44,9 @@ type System struct {
 	Ctx           context.Context       // create a context that can be cancelled
 	Sigs          chan os.Signal        // channel to initiate a graceful shutdown when Ctrl+C is pressed
 	RegistrarChan chan *CoreSystem      // channel for the lead service registrar
-	Messengers    *sync.Map             // Tracks which hosts to send log msgs to (and how many errors were encountered, before being removed)
+	// Tracks which hosts to send log msgs to (and how many errors were encountered, before being removed)
+	Messengers map[string]int
+	Mutex      *sync.Mutex
 }
 
 // CoreSystem struct holds details about the core system included in the configuration file
@@ -67,9 +69,10 @@ func NewSystem(name string, ctx context.Context) System {
 	// be a pointer instead (usually not normal) and initialised (usually not needed)
 	// in order to avoid linter errors.
 	// The errors is due to this func returning a copy of newSystem and attempts
-	// to copy the map too, but it's not allowed for sync objects.
+	// to copy the mutex too, but it's not allowed for sync objects.
 	// Reference: https://stackoverflow.com/questions/37242009/function-returns-lock-by-value
-	newSystem.Messengers = &sync.Map{}
+	newSystem.Messengers = make(map[string]int)
+	newSystem.Mutex = &sync.Mutex{}
 	return newSystem
 }
 
diff --git a/usecases/consumption.go b/usecases/consumption.go
index 22101f7..cbef54b 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -101,20 +101,20 @@ func Log(sys *components.System, lvl forms.MessageLevel, msg string, args ...any
 	sm := forms.NewSystemMessage_v1(lvl, fmt.Sprintf(msg, args...), sys.Name)
 	log.Println(sm.String()) // Always print the msg locally
 
-	body, err := Pack(forms.Form(&sm), "application/json")
-	if err != nil {
-		log.Printf("failed to pack SystemMessage: %v\n", err)
-		return
-	}
+	var body []byte
+	sys.Mutex.Lock()
+	defer sys.Mutex.Unlock()
 
 	// Iterate over all messengers and try sending a copy of the log msg
-	// (can't use a regular for-loop for this type)
-	sys.Messengers.Range(func(k, v any) bool {
-		host, ok1 := k.(string) // Should always be a host string!
-		errors, ok2 := v.(int)  // and an error count
-		if !ok1 || !ok2 {
-			sys.Messengers.Delete(k) // if not, removes the unusable cruft
-			return true              // and continue iterating
+	for host, errors := range sys.Messengers {
+		// Lazy-load the packed body, only at the first iteration
+		if body == nil {
+			var err error
+			body, err = Pack(forms.Form(&sm), "application/json")
+			if err != nil {
+				log.Printf("failed to pack SystemMessage: %v\n", err)
+				return
+			}
 		}
 
 		newErrors := 0 // If there's no error while sending msg, the count is reset
@@ -123,26 +123,26 @@ func Log(sys *components.System, lvl forms.MessageLevel, msg string, args ...any
 		}
 		if newErrors >= messengerMaxErrors {
 			// Too many errors indicates a problematic messenger
-			sys.Messengers.Delete(k)
-			return true
+			delete(sys.Messengers, host)
+			continue
 		}
-		sys.Messengers.Store(k, newErrors)
-		return true
-	})
+		sys.Messengers[host] = newErrors
+	}
 }
 
 // Hard-coding the path is ugly but it skips an extra service discovery cycle for now
-const messengerPath string = "/messenger/log/message"
+const logMessagePath string = "/log/message"
 
 func sendLogMessage(h string, b []byte) error {
-	u, err := url.Parse("http://" + h + messengerPath)
+	u, err := url.Parse(h)
 	if err != nil {
 		return err
 	}
-	resp, err := sendHTTPReq("POST", u.String(), b)
+	u = u.JoinPath(logMessagePath)
+	resp, err := sendHTTPReq(http.MethodPost, u.String(), b)
 	if err != nil {
 		return err
 	}
-	_ = resp.Body.Close() // Don't care about the body or any errors it might cause
+	_ = resp.Body.Close() // Don't care about the response body or any errors it might cause
 	return nil
 }
diff --git a/usecases/provision.go b/usecases/provision.go
index 88d19ae..f4b3b97 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -150,10 +150,12 @@ func RegisterMessenger(w http.ResponseWriter, r *http.Request, s *components.Sys
 		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 		return
 	}
-	if _, found := s.Messengers.Load(reg.Host); found {
+	s.Mutex.Lock()
+	defer s.Mutex.Unlock()
+	if _, found := s.Messengers[reg.Host]; found {
 		// The system already knows the messenger, avoid re-storing it so that
 		// the error count don't get reset
 		return
 	}
-	s.Messengers.Store(reg.Host, 0) // Registers the host with 0 errors
+	s.Messengers[reg.Host] = 0 // Registers the new messenger with zero errors
 }

From 732c4657e14e702072939eb333213f29bca84904 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Tue, 15 Jul 2025 10:52:17 +0200
Subject: [PATCH 168/186] Only verify status of registrars in
 GetRunningCoreSystemURL

---
 components/system.go | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/components/system.go b/components/system.go
index 6251ca4..cb972ad 100644
--- a/components/system.go
+++ b/components/system.go
@@ -100,24 +100,24 @@ func GetRunningCoreSystemURL(sys *System, systemType string) (string, error) {
 			lastErr = fmt.Errorf("parsing core URL: %w", err)
 			continue
 		}
+
 		coreSystemURL := coreURL.String() // Preserves the original URL
-		if systemType == ServiceRegistrarName {
-			coreURL = coreURL.JoinPath("status")
+		if core.Name != ServiceRegistrarName {
+			return coreSystemURL, nil
 		}
 
+		// Perform extra checks on the response from a service registrar
+		coreURL = coreURL.JoinPath("status")
 		body, err := verifyStatus(coreURL)
 		if err != nil {
-			lastErr = fmt.Errorf("verifying core URL: %w", err)
+			lastErr = fmt.Errorf("verifying registrar: %w", err)
 			continue
 		}
 
 		// Skips non-leading registrars
-		// TODO: race condition when the lead drops and no other registrar have
-		// picked up the slack yet? - Alex
-		if systemType == ServiceRegistrarName && !bytes.HasPrefix(body, []byte(ServiceRegistrarLeader)) {
+		if bytes.HasPrefix(body, []byte(ServiceRegistrarLeader)) == false {
 			continue
 		}
-
 		return coreSystemURL, nil
 	}
 

From 0fef178d190be0adcefbfafeb3e1deb21ecd6e8b Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Tue, 15 Jul 2025 10:52:17 +0200
Subject: [PATCH 169/186] Fixes broken tests after previous commit

---
 components/system.go               |  2 +-
 components/system_test.go          | 21 ++++++++++++---------
 usecases/consumption_test.go       | 16 +++++++++++++---
 usecases/service_discovery_test.go |  8 ++++----
 4 files changed, 30 insertions(+), 17 deletions(-)

diff --git a/components/system.go b/components/system.go
index cb972ad..6f46732 100644
--- a/components/system.go
+++ b/components/system.go
@@ -115,7 +115,7 @@ func GetRunningCoreSystemURL(sys *System, systemType string) (string, error) {
 		}
 
 		// Skips non-leading registrars
-		if bytes.HasPrefix(body, []byte(ServiceRegistrarLeader)) == false {
+		if !bytes.HasPrefix(body, []byte(ServiceRegistrarLeader)) {
 			continue
 		}
 		return coreSystemURL, nil
diff --git a/components/system_test.go b/components/system_test.go
index aa97bd2..46fc674 100644
--- a/components/system_test.go
+++ b/components/system_test.go
@@ -121,16 +121,18 @@ type sampleGetRunningCoreSystem struct {
 
 var tableGetRunningCoreSystem = []sampleGetRunningCoreSystem{
 	// Tests for non-registrars
+	// Case: unrelated system
+	{"bad name", "", true, nil},
 	// Case: url.Parse() error
 	{coreFake.Name, "", true, func(m *mockTrans) { coreFake.Url = string(rune(0)) }},
-	// Case: http.Get() error
-	{coreFake.Name, "", true, func(m *mockTrans) { m.setError() }},
-	// Case: io.ReadAll() error
-	{coreFake.Name, "", true, func(m *mockTrans) { m.setBodyError() }},
-	// Case: http < 200 error
-	{coreFake.Name, "", true, func(m *mockTrans) { m.setResponse(199, "") }},
-	// Case: http > 299 error
-	{coreFake.Name, "", true, func(m *mockTrans) { m.setResponse(300, "") }},
+	// Case: http.Get() no error
+	{coreFake.Name, coreFake.Url, false, func(m *mockTrans) { m.setError() }},
+	// Case: io.ReadAll() no error
+	{coreFake.Name, coreFake.Url, false, func(m *mockTrans) { m.setBodyError() }},
+	// Case: http < 200 no error
+	{coreFake.Name, coreFake.Url, false, func(m *mockTrans) { m.setResponse(199, "") }},
+	// Case: http > 299 no error
+	{coreFake.Name, coreFake.Url, false, func(m *mockTrans) { m.setResponse(300, "") }},
 	// Case: return url
 	{coreFake.Name, coreFake.Url, false, nil},
 
@@ -150,7 +152,8 @@ var tableGetRunningCoreSystem = []sampleGetRunningCoreSystem{
 	// Case: return url
 	{coreReg.Name, coreReg.Url, false, func(m *mockTrans) {
 		m.setResponse(200, ServiceRegistrarLeader)
-	}},
+	},
+	},
 }
 
 func TestGetRunningCoreSystem(t *testing.T) {
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index eed3b70..8c374b7 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -91,7 +91,7 @@ func createDoubleHttpResp() func() *http.Response {
 	count := 0
 	return func() *http.Response {
 		count++
-		if count == 2 || count == 5 {
+		if count == 1 || count == 3 {
 			return &http.Response{
 				Status:     "200 OK",
 				StatusCode: 200,
@@ -187,7 +187,12 @@ func TestGetState(t *testing.T) {
 
 		if test.expectedfForm != nil {
 			expected := test.expectedfForm.(*forms.SignalA_v1a)
-			actual := res.(*forms.SignalA_v1a)
+			actual, ok := res.(*forms.SignalA_v1a)
+			if !ok {
+				t.Fatalf("Test case: %s, got %v, expected a forms.Form",
+					test.testCase, res,
+				)
+			}
 			if expected.Value != actual.Value || expected.Unit != actual.Unit ||
 				expected.Timestamp != actual.Timestamp || expected.Version != actual.Version ||
 				err != test.expectedErr {
@@ -214,7 +219,12 @@ func TestSetState(t *testing.T) {
 
 		if test.expectedfForm != nil {
 			expected := test.expectedfForm.(*forms.SignalA_v1a)
-			actual := res.(*forms.SignalA_v1a)
+			actual, ok := res.(*forms.SignalA_v1a)
+			if !ok {
+				t.Fatalf("Test case: %s, got %v, expected a forms.Form",
+					test.testCase, res,
+				)
+			}
 			if expected.Value != actual.Value || expected.Unit != actual.Unit ||
 				expected.Timestamp != actual.Timestamp || expected.Version != actual.Version ||
 				err != test.expectedErr {
diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index c663a23..a753a67 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -223,12 +223,12 @@ func TestSearch4Service(t *testing.T) {
 		{
 			true,
 			createMultiHttpResp(200, false, 0),
-			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 2, errHTTP) },
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 1, errHTTP) },
 			"Bad case, error sending http request",
 		},
 		{
 			true,
-			createMultiHttpResp(200, true, 2),
+			createMultiHttpResp(200, true, 1),
 			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
 			"Bad case, error reading response body",
 		},
@@ -311,7 +311,7 @@ func TestSearch4Services(t *testing.T) {
 				return
 			},
 			createMultiHttpResp(200, false, 0),
-			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 2, errHTTP) },
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 1, errHTTP) },
 			"Bad case, sendHttpReq() returns an error",
 		},
 		{
@@ -321,7 +321,7 @@ func TestSearch4Services(t *testing.T) {
 				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
 				return
 			},
-			createMultiHttpResp(200, true, 2),
+			createMultiHttpResp(200, true, 1),
 			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
 			"Bad case, error while reading body",
 		},

From a6fb49c45609b66aed223a64e0898ab455012a3f Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Tue, 15 Jul 2025 16:35:50 +0200
Subject: [PATCH 170/186] Started working on making functions that return a
 list of services instead of just one

---
 usecases/consumption.go       | 54 ++++++++++++++++++++++++++++++
 usecases/service_discovery.go | 62 +++++++++++++++++++++++++++++++++++
 2 files changed, 116 insertions(+)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index 8f5ac96..6c663e8 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -34,11 +34,19 @@ func GetState(cer *components.Cervice, sys *components.System) (f forms.Form, er
 	return stateHandler(http.MethodGet, cer, sys, nil)
 }
 
+func GetStates(cer *components.Cervice, sys *components.System) (f []forms.Form, err error) {
+	return stateHandlers(http.MethodGet, cer, sys, nil)
+}
+
 // SetState puts a request to change the state of a unit asset (via the asset's service)
 func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte) (f forms.Form, err error) {
 	return stateHandler(http.MethodPut, cer, sys, bodyBytes)
 }
 
+func SetStates(cer *components.Cervice, sys *components.System, bodyBytes []byte) (f []forms.Form, err error) {
+	return stateHandlers(http.MethodPut, cer, sys, bodyBytes)
+}
+
 func stateHandler(httpMethod string, cer *components.Cervice, sys *components.System, bodyBytes []byte) (f forms.Form, err error) {
 	if len(cer.Nodes) == 0 {
 		err := Search4Services(cer, sys)
@@ -76,3 +84,49 @@ func stateHandler(httpMethod string, cer *components.Cervice, sys *components.Sy
 	headerContentType := resp.Header.Get("Content-Type")
 	return Unpack(bodyBytes, headerContentType)
 }
+
+func stateHandlers(httpMethod string, cer *components.Cervice, sys *components.System, bodyBytes []byte) (f []forms.Form, err error) {
+	if len(cer.Nodes) == 0 {
+		err := Search4MultipleServices(cer, sys)
+		if err != nil {
+			return f, err
+		}
+	}
+
+	// Preallocate serviceUrl with the number of nodes
+	serviceUrls := make([]string, len(cer.Nodes))
+	index := 0
+	for _, values := range cer.Nodes {
+		if len(values) > 0 {
+			serviceUrls[index] = values[0]
+		}
+		index++
+	}
+
+	for _, serviceUrl := range serviceUrls {
+		resp, err := sendHttpReq(httpMethod, serviceUrl, bodyBytes)
+		if err != nil {
+			cer.Nodes = make(map[string][]string)
+			continue
+		}
+		defer resp.Body.Close()
+
+		// If the response includes a payload, unpack it into a forms.Form
+		bodyBytes, err = io.ReadAll(resp.Body)
+		if err != nil {
+			return f, fmt.Errorf("reading state response body: %w", err)
+		}
+
+		if len(bodyBytes) < 1 {
+			return f, fmt.Errorf("got empty response body")
+		}
+
+		headerContentType := resp.Header.Get("Content-Type")
+		formValue, err := Unpack(bodyBytes, headerContentType)
+		if err != nil {
+			return f, fmt.Errorf("unpacking response body: %w", err)
+		}
+		f = append(f, formValue)
+	}
+	return f, err
+}
diff --git a/usecases/service_discovery.go b/usecases/service_discovery.go
index 701f579..58de31b 100644
--- a/usecases/service_discovery.go
+++ b/usecases/service_discovery.go
@@ -25,6 +25,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"strconv"
 
 	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
@@ -167,6 +168,67 @@ func Search4Services(cer *components.Cervice, sys *components.System) (err error
 	return nil
 }
 
+func Search4MultipleServices(cer *components.Cervice, sys *components.System) (err error) {
+	questForm := forms.ServiceQuest_v1{
+		SysId:             0,
+		RequesterName:     sys.Name,
+		ServiceDefinition: cer.Definition,
+		Protocol:          "http",
+		Details:           cer.Details,
+		Version:           "ServiceQuest_v1",
+	}
+	// Pack the service quest form
+	qf, err := Pack(&questForm, "application/json")
+	if err != nil {
+		return err
+	}
+	// Search for an Orchestrator system within the local cloud
+	orURL, err := components.GetRunningCoreSystemURL(sys, "orchestrator")
+	if err != nil {
+		return err
+	}
+	if orURL == "" {
+		return fmt.Errorf("failed to locate an orchestrator")
+	}
+	orURL = orURL + "/squests"
+	// Prepare the request to the orchestrator
+	resp, err := sendHttpReq(http.MethodPost, orURL, qf)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	// Read the response /////////////////////////////////
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	headerContentType := resp.Header.Get("Content-Type")
+	discoveryForm, err := Unpack(bodyBytes, headerContentType)
+	if err != nil {
+		return err
+	}
+	srList, ok := discoveryForm.(*forms.ServiceRecordList_v1)
+	if !ok {
+		return fmt.Errorf("unable to unpack discovery request form")
+	}
+	for _, values := range srList.List {
+		sp := convertToServicePoint(values)
+		cer.Nodes[sp.ServNode] = append(cer.Nodes[sp.ServNode], sp.ServLocation)
+	}
+	return nil
+}
+
+func convertToServicePoint(sr forms.ServiceRecord_v1) (sp forms.ServicePoint_v1) {
+	rec := sr
+	sp.NewForm()
+	sp.ProviderName = rec.SystemName
+	sp.ServiceDefinition = rec.ServiceDefinition
+	sp.Details = rec.Details
+	sp.ServLocation = "http://" + rec.IPAddresses[0] + ":" + strconv.Itoa(rec.ProtoPort["http"]) + "/" + rec.SystemName + "/" + rec.SubPath
+	sp.ServNode = rec.ServiceNode
+	return
+}
+
 // FillDiscoveredServices returns a json data byte array with a slice of matching services (e.g., Service Registrar)
 func FillDiscoveredServices(dsList []forms.ServiceRecord_v1, version string) (f forms.Form, err error) {
 	switch version {

From b85f77bedb9c1a7773f8a47aba14d7ebaf40b0f9 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Tue, 15 Jul 2025 16:05:16 +0200
Subject: [PATCH 171/186] Adds helper to translate message levels

---
 forms/message_forms.go | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/forms/message_forms.go b/forms/message_forms.go
index 58d2ada..977df4d 100644
--- a/forms/message_forms.go
+++ b/forms/message_forms.go
@@ -47,6 +47,21 @@ const (
 	LevelError MessageLevel = 8
 )
 
+func LevelToString(lvl MessageLevel) string {
+	switch lvl {
+	case LevelDebug:
+		return "DEBUG"
+	case LevelInfo:
+		return "INFO"
+	case LevelWarn:
+		return "WARN"
+	case LevelError:
+		return "ERROR"
+	default:
+		return "UNKNOWN"
+	}
+}
+
 // A SystemMessage is a log message sent from a system to one or many messengers.
 // The receiving messengers will note the message's time of arrival.
 type SystemMessage_v1 struct {
@@ -68,20 +83,7 @@ func NewSystemMessage_v1(l MessageLevel, b string, s string) SystemMessage_v1 {
 }
 
 func (f SystemMessage_v1) String() string {
-	var lvl string
-	switch f.Level {
-	case LevelDebug:
-		lvl = "DEBUG"
-	case LevelInfo:
-		lvl = "INFO"
-	case LevelWarn:
-		lvl = "WARN"
-	case LevelError:
-		lvl = "ERROR"
-	default:
-		lvl = "UNKNOWN"
-	}
-	return fmt.Sprintf("%s %s", lvl, f.Body)
+	return fmt.Sprintf("%s %s", LevelToString(f.Level), f.Body)
 }
 
 // NewForm resets the form and defaults to using LevelInfo.

From cdb74253b63fdae0e090d310f0d8da20adfeed55 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 23 Jul 2025 12:11:29 +0200
Subject: [PATCH 172/186] Cleans up error handling for the messenger

---
 usecases/consumption.go | 9 +++++----
 usecases/provision.go   | 9 +++++++--
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index cbef54b..4619661 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -117,16 +117,17 @@ func Log(sys *components.System, lvl forms.MessageLevel, msg string, args ...any
 			}
 		}
 
-		newErrors := 0 // If there's no error while sending msg, the count is reset
+		errCount := 0 // If there's no error while sending msg, the count is reset
 		if err := sendLogMessage(host, body); err != nil {
-			newErrors = errors + 1
+			// Don't care what kinds of errors might be returned
+			errCount = errors + 1
 		}
-		if newErrors >= messengerMaxErrors {
+		if errCount >= messengerMaxErrors {
 			// Too many errors indicates a problematic messenger
 			delete(sys.Messengers, host)
 			continue
 		}
-		sys.Messengers[host] = newErrors
+		sys.Messengers[host] = errCount
 	}
 }
 
diff --git a/usecases/provision.go b/usecases/provision.go
index f4b3b97..41f9095 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -138,18 +138,23 @@ func RegisterMessenger(w http.ResponseWriter, r *http.Request, s *components.Sys
 	}
 	defer r.Body.Close()
 
+	// Won't bother logging the following errors as they are caused by bad/poor
+	// client requests, which we don't really care about on the server side.
 	f, err := Unpack(b, r.Header.Get("Content-Type"))
 	if err != nil {
-		log.Printf("unpack: %v\n", err)
 		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 		return
 	}
 	reg, ok := f.(*forms.MessengerRegistration_v1)
 	if !ok {
-		log.Println("form is not a MessengerRegistration_v1")
 		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 		return
 	}
+	if len(reg.Host) < 1 {
+		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+		return
+	}
+
 	s.Mutex.Lock()
 	defer s.Mutex.Unlock()
 	if _, found := s.Messengers[reg.Host]; found {

From 4bea4e77c150037612ffc9b140a7c413ff6264f0 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 23 Jul 2025 12:11:29 +0200
Subject: [PATCH 173/186] Adds tests for RegisterMessenger

---
 usecases/provision_test.go | 73 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)

diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index 42e2f18..c5fbe7d 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -1,6 +1,7 @@
 package usecases
 
 import (
+	"context"
 	"encoding/xml"
 	"fmt"
 	"io"
@@ -9,6 +10,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
 )
 
@@ -173,3 +175,74 @@ func TestGetBestContentType(t *testing.T) {
 		}
 	}
 }
+
+const testMessenger string = "testmessenger"
+const testRegMesForm string = `{"version": "MessengerRegistration_v1", "host": "` + testMessenger + `"}`
+
+func TestRegisterMessenger(t *testing.T) {
+	table := []struct {
+		method         string
+		contentType    string
+		body           io.ReadCloser
+		expectedStatus int
+	}{
+		// Bad method
+		{http.MethodGet, "application/json", nil, http.StatusMethodNotAllowed},
+		// Bad body
+		{http.MethodPost, "application/json", errReader(0), http.StatusInternalServerError},
+		// Bad unpack
+		{http.MethodPost, "bad type", nil, http.StatusBadRequest},
+		// Bad form
+		{http.MethodPost, "application/json",
+			io.NopCloser(strings.NewReader(`{"version": "SystemMessage_v1"}`)),
+			http.StatusBadRequest,
+		},
+		// Missing host
+		{http.MethodPost, "application/json",
+			io.NopCloser(strings.NewReader(`{"version": "MessengerRegistration_v1"}`)),
+			http.StatusBadRequest,
+		},
+		// All good
+		// WARN: this case is expected to be the last one in this table, as its
+		// result is being used in the special cases!
+		{http.MethodPost, "application/json",
+			io.NopCloser(strings.NewReader(testRegMesForm)),
+			http.StatusOK,
+		},
+	}
+
+	s := components.NewSystem("testsys", context.Background())
+	testFunc := func(method, content string, body io.ReadCloser) *http.Response {
+		w := httptest.NewRecorder()
+		r := httptest.NewRequest(method, "/msg", body)
+		r.Header.Set("Content-Type", content)
+		RegisterMessenger(w, r, &s)
+
+		return w.Result()
+	}
+	for _, test := range table {
+		res := testFunc(test.method, test.contentType, test.body)
+		if got, want := res.StatusCode, test.expectedStatus; got != want {
+			t.Errorf("expected status %d, got %d", want, got)
+		}
+	}
+
+	// Verify the messenger was registered from the last test case
+	errors, found := s.Messengers[testMessenger]
+	if errors != 0 || found == false {
+		t.Errorf("expected registered messenger, found none")
+	}
+
+	// Verify duplicate registration doesn't lose error count
+	errCount := -1
+	s.Messengers[testMessenger] = errCount
+	res := testFunc(http.MethodPost, "application/json",
+		io.NopCloser(strings.NewReader(testRegMesForm)),
+	)
+	if got, want := res.StatusCode, http.StatusOK; got != want {
+		t.Errorf("expected status %d, got %d", want, got)
+	}
+	if got, want := s.Messengers[testMessenger], errCount; got != want {
+		t.Errorf("expected error count %d, got %d", want, got)
+	}
+}

From bd81adf25bbae1395b6f5e5327d7eb00aa73e5c5 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 23 Jul 2025 16:42:07 +0200
Subject: [PATCH 174/186] Adds first test cases for Log()

---
 usecases/consumption.go      |  7 +++--
 usecases/consumption_test.go | 59 ++++++++++++++++++++++++++++++++++++
 2 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index 4619661..5c9b1ad 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -23,6 +23,7 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"testing"
 
 	"net/http"
 	"net/url"
@@ -99,8 +100,10 @@ func LogError(sys *components.System, msg string, args ...any) {
 
 func Log(sys *components.System, lvl forms.MessageLevel, msg string, args ...any) {
 	sm := forms.NewSystemMessage_v1(lvl, fmt.Sprintf(msg, args...), sys.Name)
-	log.Println(sm.String()) // Always print the msg locally
-
+	if !testing.Testing() {
+		// Only print the msg locally if not running go test
+		log.Println(sm.String())
+	}
 	var body []byte
 	sys.Mutex.Lock()
 	defer sys.Mutex.Unlock()
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index eed3b70..7c92201 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -1,8 +1,10 @@
 package usecases
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
 	"log"
 	"net/http"
@@ -226,3 +228,60 @@ func TestSetState(t *testing.T) {
 		}
 	}
 }
+
+type logTransportMock struct {
+	t *testing.T
+}
+
+func newLogTransportMock(t *testing.T) *logTransportMock {
+	lt := &logTransportMock{t}
+	http.DefaultClient.Transport = lt
+	return lt
+}
+
+var logError = fmt.Errorf("mock error")
+
+func (lt *logTransportMock) RoundTrip(req *http.Request) (res *http.Response, err error) {
+	b, err := io.ReadAll(req.Body)
+	if err != nil {
+		lt.t.Errorf("unexpected error while reading request body: %v", err)
+		return
+	}
+	defer req.Body.Close()
+	f, err := Unpack(b, req.Header.Get("Content-Type"))
+	if err != nil {
+		lt.t.Errorf("unexpected error from unpack: %v", err)
+		return
+	}
+	m, ok := f.(*forms.SystemMessage_v1)
+	if !ok {
+		lt.t.Error("unexpected form")
+		return
+	}
+	if m.System != testLogSys || m.Body != testLogMsg {
+		lt.t.Errorf("unexpected message: %v", m)
+	}
+	err = fmt.Errorf("mock error")
+	return
+}
+
+const testLogHost = "host"
+const testLogSys = "test system"
+const testLogMsg = "test msg"
+
+func TestLog(t *testing.T) {
+	newLogTransportMock(t)
+	s := components.NewSystem(testLogSys, context.Background())
+	s.Messengers[testLogHost] = 0
+	Log(&s, forms.LevelDebug, testLogMsg)
+	if got, want := s.Messengers[testLogHost], 1; got != want {
+		t.Errorf("expected error count %d, got %d", want, got)
+	}
+
+	s.Messengers[testLogHost] = messengerMaxErrors
+	Log(&s, forms.LevelDebug, testLogMsg)
+	_, found := s.Messengers[testLogHost]
+	if found {
+		t.Errorf("expected messenger being removed")
+	}
+}

From 52845e60eec9d0715ee85c0307d4d0e7181272ca Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 24 Jul 2025 08:40:49 +0200
Subject: [PATCH 175/186] Finishes Log testing

---
 usecases/consumption.go      |  2 +-
 usecases/consumption_test.go | 36 ++++++++++++++++++++++++++++++------
 2 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index 5c9b1ad..6e7e31a 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -101,7 +101,7 @@ func LogError(sys *components.System, msg string, args ...any) {
 func Log(sys *components.System, lvl forms.MessageLevel, msg string, args ...any) {
 	sm := forms.NewSystemMessage_v1(lvl, fmt.Sprintf(msg, args...), sys.Name)
 	if !testing.Testing() {
-		// Only print the msg locally if not running go test
+		// Only print the msg locally if not running during `go test`
 		log.Println(sm.String())
 	}
 	var body []byte
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index 7c92201..754415d 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -8,6 +8,7 @@ import (
 	"io"
 	"log"
 	"net/http"
+	"net/http/httptest"
 	"strings"
 	"testing"
 
@@ -230,17 +231,21 @@ func TestSetState(t *testing.T) {
 }
 
 type logTransportMock struct {
-	t *testing.T
+	t           *testing.T
+	errResponse error
 }
 
 func newLogTransportMock(t *testing.T) *logTransportMock {
-	lt := &logTransportMock{t}
+	lt := &logTransportMock{t, nil}
 	http.DefaultClient.Transport = lt
 	return lt
 }
 
-var logError = fmt.Errorf("mock error")
+func (lt *logTransportMock) setError(err error) {
+	lt.errResponse = err
+}
 
+// This mock transport also verifies that the system message forms are valid.
 func (lt *logTransportMock) RoundTrip(req *http.Request) (res *http.Response, err error) {
 	b, err := io.ReadAll(req.Body)
 	if err != nil {
@@ -261,27 +266,46 @@ func (lt *logTransportMock) RoundTrip(req *http.Request) (res *http.Response, er
 	if m.System != testLogSys || m.Body != testLogMsg {
 		lt.t.Errorf("unexpected message: %v", m)
 	}
-	err = fmt.Errorf("mock error")
-	return
+
+	if lt.errResponse != nil {
+		return nil, lt.errResponse
+	}
+	rec := httptest.NewRecorder()
+	rec.WriteHeader(http.StatusOK)
+	return rec.Result(), nil
 }
 
 const testLogHost = "host"
 const testLogSys = "test system"
 const testLogMsg = "test msg"
 
+// NOTE: this test also covers sendLogMessage function
+
 func TestLog(t *testing.T) {
-	newLogTransportMock(t)
+	lt := newLogTransportMock(t)
+	lt.setError(fmt.Errorf("mock err"))
 	s := components.NewSystem(testLogSys, context.Background())
+
+	// Case: increase error count by one
 	s.Messengers[testLogHost] = 0
 	Log(&s, forms.LevelDebug, testLogMsg)
 	if got, want := s.Messengers[testLogHost], 1; got != want {
 		t.Errorf("expected error count %d, got %d", want, got)
 	}
 
+	// Case: removes messenger after too many errors
 	s.Messengers[testLogHost] = messengerMaxErrors
 	Log(&s, forms.LevelDebug, testLogMsg)
 	_, found := s.Messengers[testLogHost]
 	if found {
 		t.Errorf("expected messenger being removed")
 	}
+
+	// Case: transfer ok
+	lt.setError(nil)
+	s.Messengers[testLogHost] = 0
+	Log(&s, forms.LevelDebug, testLogMsg)
+	if got, want := s.Messengers[testLogHost], 0; got != want {
+		t.Errorf("expected error count %d, got %d", want, got)
+	}
 }

From beb8ddf1127b18f38aff841117f14441c2afe784 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Thu, 24 Jul 2025 11:21:54 +0200
Subject: [PATCH 176/186] Skip logging error that we can't do anything about
 anyway

---
 usecases/provision.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/usecases/provision.go b/usecases/provision.go
index 41f9095..bf1a0b5 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -131,9 +131,7 @@ func RegisterMessenger(w http.ResponseWriter, r *http.Request, s *components.Sys
 
 	b, err := io.ReadAll(r.Body)
 	if err != nil {
-		log.Printf("read request body: %v\n", err)
-		http.Error(w, http.StatusText(http.StatusInternalServerError),
-			http.StatusInternalServerError)
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 		return
 	}
 	defer r.Body.Close()

From 30a34611194edc4dda962084049f5b7b5906d0a3 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Fri, 25 Jul 2025 10:05:54 +0200
Subject: [PATCH 177/186] Continued working on the GetStates function and tests
 for it

---
 usecases/consumption.go            |  22 ++--
 usecases/consumption_test.go       |  89 ++++++++++++++++
 usecases/service_discovery_test.go | 158 +++++++++++++++++++++++++++++
 3 files changed, 261 insertions(+), 8 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index 6c663e8..1ee1fa3 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -34,6 +34,7 @@ func GetState(cer *components.Cervice, sys *components.System) (f forms.Form, er
 	return stateHandler(http.MethodGet, cer, sys, nil)
 }
 
+// GetStates requests the current state of certain services of a unit asset depending on requested definition and/or details
 func GetStates(cer *components.Cervice, sys *components.System) (f []forms.Form, err error) {
 	return stateHandlers(http.MethodGet, cer, sys, nil)
 }
@@ -43,10 +44,6 @@ func SetState(cer *components.Cervice, sys *components.System, bodyBytes []byte)
 	return stateHandler(http.MethodPut, cer, sys, bodyBytes)
 }
 
-func SetStates(cer *components.Cervice, sys *components.System, bodyBytes []byte) (f []forms.Form, err error) {
-	return stateHandlers(http.MethodPut, cer, sys, bodyBytes)
-}
-
 func stateHandler(httpMethod string, cer *components.Cervice, sys *components.System, bodyBytes []byte) (f forms.Form, err error) {
 	if len(cer.Nodes) == 0 {
 		err := Search4Services(cer, sys)
@@ -103,10 +100,16 @@ func stateHandlers(httpMethod string, cer *components.Cervice, sys *components.S
 		index++
 	}
 
+	var lastErr error
+
 	for _, serviceUrl := range serviceUrls {
+		if len(serviceUrl) == 0 {
+			continue
+		}
 		resp, err := sendHttpReq(httpMethod, serviceUrl, bodyBytes)
 		if err != nil {
 			cer.Nodes = make(map[string][]string)
+			lastErr = err
 			continue
 		}
 		defer resp.Body.Close()
@@ -114,19 +117,22 @@ func stateHandlers(httpMethod string, cer *components.Cervice, sys *components.S
 		// If the response includes a payload, unpack it into a forms.Form
 		bodyBytes, err = io.ReadAll(resp.Body)
 		if err != nil {
-			return f, fmt.Errorf("reading state response body: %w", err)
+			lastErr = fmt.Errorf("reading state response body: %w", err)
+			continue
 		}
 
 		if len(bodyBytes) < 1 {
-			return f, fmt.Errorf("got empty response body")
+			lastErr = fmt.Errorf("got empty response body")
+			continue
 		}
 
 		headerContentType := resp.Header.Get("Content-Type")
 		formValue, err := Unpack(bodyBytes, headerContentType)
 		if err != nil {
-			return f, fmt.Errorf("unpacking response body: %w", err)
+			lastErr = fmt.Errorf("unpacking response body: %w", err)
+			continue
 		}
 		f = append(f, formValue)
 	}
-	return f, err
+	return f, lastErr
 }
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index 8c374b7..a7bb23d 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -236,3 +236,92 @@ func TestSetState(t *testing.T) {
 		}
 	}
 }
+
+func createDoubleHttpRespWithServRecList() func() *http.Response {
+	f := createServiceRecordListTestForm()
+	// Create mock response from orchestrator
+	fakeBody, err := json.Marshal(f)
+	if err != nil {
+		log.Println("Fail Marshal at start of test")
+	}
+	count := 0
+	return func() *http.Response {
+		count++
+		if count == 1 || count == 3 {
+			return &http.Response{
+				Status:     "200 OK",
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+			}
+		}
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body: io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n " +
+				" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
+		}
+	}
+}
+
+type getStatesTestStruct struct {
+	testCer          *components.Cervice
+	bodyBytes        []byte
+	body             func() *http.Response
+	mockTransportErr int
+	errHTTP          error
+	expectedForm     forms.Form
+	expectedErr      error
+	testName         string
+}
+
+var getStatesTestParams = []getStatesTestStruct{
+	{newTestCerviceWithNodes(), createTestBytes(), createWorkingHttpResp(), 0, nil, form.NewForm(),
+		nil, "No errors with nodes"},
+	{newTestCerviceWithoutNodes(), createTestBytes(), createDoubleHttpRespWithServRecList(), 0, nil, form.NewForm(),
+		nil, "No errors without nodes"},
+	{newTestCerviceWithNodes(), nil, createEmptyHttpResp(), 0, nil, nil,
+		errEmptyRespBody, "Empty response body error"},
+	{newTestCerviceWithoutNodes(), createTestBytes(), createWorkingHttpResp(), 1, errHTTP, nil,
+		errHTTP, "Search4Services error"},
+	{newTestCerviceWithBrokenUrl(), createTestBytes(), createWorkingHttpResp(), 2, errHTTP, nil,
+		errHTTP, "NewRequest() error"},
+	{newTestCerviceWithNodes(), createTestBytes(), createStatusErrorHttpResp(), 2, errHTTP, nil,
+		errHTTP, "Status code error"},
+	{newTestCerviceWithNodes(), createTestBytes(), createErrorReaderHttpResp(), 0, nil, nil,
+		errBodyRead, "io.ReadAll() error"},
+	{newTestCerviceWithNodes(), createTestBytes(), createUnpackErrorHttpResp(), 0, nil, nil,
+		errUnpack, "Unpack() error"},
+	{newTestCerviceWithNodes(), createTestBytes(), createWorkingHttpResp(), 1, errHTTP, nil,
+		errHTTP, "DefaultClient.Do() error"},
+}
+
+func TestGetStates(t *testing.T) {
+	for _, testCase := range getStatesTestParams {
+		testSys := createTestSystem(false)
+		newMockTransport(testCase.body, testCase.mockTransportErr, testCase.errHTTP)
+
+		res, err := GetStates(testCase.testCer, &testSys)
+
+		if testCase.expectedForm != nil {
+			expected := testCase.expectedForm.(*forms.SignalA_v1a)
+			for _, form := range res {
+				actual, ok := form.(*forms.SignalA_v1a)
+				if !ok {
+					t.Fatalf("Test case: %s, got %v, expected a forms.Form",
+						testCase.testName, form,
+					)
+				}
+				if expected.Value != actual.Value || expected.Unit != actual.Unit ||
+					expected.Timestamp != actual.Timestamp || expected.Version != actual.Version ||
+					err != testCase.expectedErr {
+					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v",
+						testCase.testName, err, expected, actual)
+				}
+			}
+		} else if err == nil {
+			t.Errorf("Test case: %s got error: %v:", testCase.testName, err)
+		}
+	}
+}
diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index a753a67..fc9fa25 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -487,3 +487,161 @@ func TestExtractDiscoveryForm(t *testing.T) {
 		}
 	}
 }
+
+func createServiceRecordListTestForm() forms.ServiceRecordList_v1 {
+	var f forms.ServiceRecordList_v1
+	f.NewForm()
+	f.List = make([]forms.ServiceRecord_v1, 1)
+	f.List[0].IPAddresses = []string{"123.456.789"}
+	f.List[0].ProtoPort = map[string]int{"http": 123}
+	return f
+}
+
+func createMultiHttpRespWithServRecList(statusCode int, broken bool, allowedReads int) func() *http.Response {
+	f := createServiceRecordListTestForm()
+	// Create mock response from orchestrator
+	fakeBody, err := json.Marshal(f)
+	if err != nil {
+		log.Println("Fail Marshal at start of test")
+	}
+	count := allowedReads
+	return func() *http.Response {
+		count--
+		if broken == true && count == 0 {
+			return &http.Response{
+				StatusCode: 200,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       errReader(0),
+			}
+		}
+		return &http.Response{
+			StatusCode: statusCode,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
+		}
+	}
+}
+
+type search4MultipleServicesParams struct {
+	expectError bool
+	setup       func() (*components.Cervice, components.System)
+	response    func() *http.Response
+	transport   func(func() *http.Response) *mockTransport
+	testCase    string
+}
+
+func TestSearch4MultipleServices(t *testing.T) {
+	params := []search4MultipleServicesParams{
+		{
+			false,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpRespWithServRecList(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Best case, no errors",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpRespWithServRecList(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 1, errHTTP) },
+			"Bad case, GetRunningCoreSystemURL() returns error",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				for i, cs := range sys.CoreS {
+					if cs.Name == "orchestrator" {
+						(*sys.CoreS[i]).Url = ""
+					}
+				}
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpRespWithServRecList(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Bad case, Orchestrator url is empty",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpRespWithServRecList(200, false, 0),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 1, errHTTP) },
+			"Bad case, sendHttpReq() returns an error",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			createMultiHttpRespWithServRecList(200, true, 1),
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Bad case, error while reading body",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			func() *http.Response {
+				return &http.Response{
+					Status:     "200 OK",
+					StatusCode: 200,
+					Header:     http.Header{"Content-Type": []string{"Error"}},
+					Body:       io.NopCloser(strings.NewReader(string(""))),
+				}
+			},
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Bad case, error during Unpack",
+		},
+		{
+			true,
+			func() (cer *components.Cervice, sys components.System) {
+				sys = createTestSystem(false)
+				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+				return
+			},
+			func() *http.Response {
+				return &http.Response{
+					Status:     "200 OK",
+					StatusCode: 200,
+					Header:     http.Header{"Content-Type": []string{"application/json"}},
+					Body:       io.NopCloser(strings.NewReader(string(`{"version":"SignalA_v1.0"}`))),
+				}
+			},
+			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
+			"Bad case, error during type conversion",
+		},
+	}
+
+	for _, c := range params {
+		// Setup
+		c.transport(c.response)
+		cer, sys := c.setup()
+
+		// Test
+		err := Search4MultipleServices(cer, &sys)
+		if (c.expectError == false) && (err != nil) {
+			t.Errorf("Expected no errors in '%s', got: %v", c.testCase, err)
+		}
+		if (c.expectError == true) && (err == nil) {
+			t.Errorf("Expected errors in '%s'", c.testCase)
+		}
+	}
+}

From c5c587d08e45bac7ff2d54c863739aba955a7de0 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 25 Jul 2025 13:19:09 +0200
Subject: [PATCH 178/186] Replaces single letter variables for readability

---
 forms/message_forms.go       |  8 +++---
 usecases/consumption.go      |  6 ++---
 usecases/consumption_test.go | 52 ++++++++++++++++++------------------
 usecases/provision.go        | 32 +++++++++++-----------
 usecases/provision_test.go   | 18 ++++++-------
 5 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/forms/message_forms.go b/forms/message_forms.go
index 977df4d..d73994c 100644
--- a/forms/message_forms.go
+++ b/forms/message_forms.go
@@ -73,11 +73,11 @@ type SystemMessage_v1 struct {
 
 const systemMessageVersion string = "SystemMessage_v1"
 
-func NewSystemMessage_v1(l MessageLevel, b string, s string) SystemMessage_v1 {
+func NewSystemMessage_v1(lvl MessageLevel, body string, system string) SystemMessage_v1 {
 	return SystemMessage_v1{
-		Level:   l,
-		Body:    b,
-		System:  s,
+		Level:   lvl,
+		Body:    body,
+		System:  system,
 		Version: systemMessageVersion,
 	}
 }
diff --git a/usecases/consumption.go b/usecases/consumption.go
index 6e7e31a..4e31025 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -137,13 +137,13 @@ func Log(sys *components.System, lvl forms.MessageLevel, msg string, args ...any
 // Hard-coding the path is ugly but it skips an extra service discovery cycle for now
 const logMessagePath string = "/log/message"
 
-func sendLogMessage(h string, b []byte) error {
-	u, err := url.Parse(h)
+func sendLogMessage(host string, body []byte) error {
+	u, err := url.Parse(host)
 	if err != nil {
 		return err
 	}
 	u = u.JoinPath(logMessagePath)
-	resp, err := sendHTTPReq(http.MethodPost, u.String(), b)
+	resp, err := sendHTTPReq(http.MethodPost, u.String(), body)
 	if err != nil {
 		return err
 	}
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index ffb632c..34b40f3 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -251,34 +251,34 @@ func newLogTransportMock(t *testing.T) *logTransportMock {
 	return lt
 }
 
-func (lt *logTransportMock) setError(err error) {
-	lt.errResponse = err
+func (mock *logTransportMock) setError(err error) {
+	mock.errResponse = err
 }
 
 // This mock transport also verifies that the system message forms are valid.
-func (lt *logTransportMock) RoundTrip(req *http.Request) (res *http.Response, err error) {
-	b, err := io.ReadAll(req.Body)
+func (mock *logTransportMock) RoundTrip(req *http.Request) (res *http.Response, err error) {
+	body, err := io.ReadAll(req.Body)
 	if err != nil {
-		lt.t.Errorf("unexpected error while reading request body: %v", err)
+		mock.t.Errorf("unexpected error while reading request body: %v", err)
 		return
 	}
 	defer req.Body.Close()
-	f, err := Unpack(b, req.Header.Get("Content-Type"))
+	form, err := Unpack(body, req.Header.Get("Content-Type"))
 	if err != nil {
-		lt.t.Errorf("unexpected error from unpack: %v", err)
+		mock.t.Errorf("unexpected error from unpack: %v", err)
 		return
 	}
-	m, ok := f.(*forms.SystemMessage_v1)
+	message, ok := form.(*forms.SystemMessage_v1)
 	if !ok {
-		lt.t.Error("unexpected form")
+		mock.t.Error("unexpected form")
 		return
 	}
-	if m.System != testLogSys || m.Body != testLogMsg {
-		lt.t.Errorf("unexpected message: %v", m)
+	if message.System != testLogSys || message.Body != testLogMsg {
+		mock.t.Errorf("unexpected message: %v", message)
 	}
 
-	if lt.errResponse != nil {
-		return nil, lt.errResponse
+	if mock.errResponse != nil {
+		return nil, mock.errResponse
 	}
 	rec := httptest.NewRecorder()
 	rec.WriteHeader(http.StatusOK)
@@ -292,30 +292,30 @@ const testLogMsg = "test msg"
 // NOTE: this test also covers sendLogMessage function
 
 func TestLog(t *testing.T) {
-	lt := newLogTransportMock(t)
-	lt.setError(fmt.Errorf("mock err"))
-	s := components.NewSystem(testLogSys, context.Background())
+	mock := newLogTransportMock(t)
+	mock.setError(fmt.Errorf("mock err"))
+	sys := components.NewSystem(testLogSys, context.Background())
 
 	// Case: increase error count by one
-	s.Messengers[testLogHost] = 0
-	Log(&s, forms.LevelDebug, testLogMsg)
-	if got, want := s.Messengers[testLogHost], 1; got != want {
+	sys.Messengers[testLogHost] = 0
+	Log(&sys, forms.LevelDebug, testLogMsg)
+	if got, want := sys.Messengers[testLogHost], 1; got != want {
 		t.Errorf("expected error count %d, got %d", want, got)
 	}
 
 	// Case: removes messenger after too many errors
-	s.Messengers[testLogHost] = messengerMaxErrors
-	Log(&s, forms.LevelDebug, testLogMsg)
-	_, found := s.Messengers[testLogHost]
+	sys.Messengers[testLogHost] = messengerMaxErrors
+	Log(&sys, forms.LevelDebug, testLogMsg)
+	_, found := sys.Messengers[testLogHost]
 	if found {
 		t.Errorf("expected messenger being removed")
 	}
 
 	// Case: transfer ok
-	lt.setError(nil)
-	s.Messengers[testLogHost] = 0
-	Log(&s, forms.LevelDebug, testLogMsg)
-	if got, want := s.Messengers[testLogHost], 0; got != want {
+	mock.setError(nil)
+	sys.Messengers[testLogHost] = 0
+	Log(&sys, forms.LevelDebug, testLogMsg)
+	if got, want := sys.Messengers[testLogHost], 0; got != want {
 		t.Errorf("expected error count %d, got %d", want, got)
 	}
 }
diff --git a/usecases/provision.go b/usecases/provision.go
index bf1a0b5..f731cba 100644
--- a/usecases/provision.go
+++ b/usecases/provision.go
@@ -123,42 +123,42 @@ func getBestContentType(acceptHeader string) string {
 	return bestType
 }
 
-func RegisterMessenger(w http.ResponseWriter, r *http.Request, s *components.System) {
-	if r.Method != "POST" {
-		http.Error(w, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
+func RegisterMessenger(resp http.ResponseWriter, req *http.Request, sys *components.System) {
+	if req.Method != "POST" {
+		http.Error(resp, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
 		return
 	}
 
-	b, err := io.ReadAll(r.Body)
+	body, err := io.ReadAll(req.Body)
 	if err != nil {
-		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		http.Error(resp, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 		return
 	}
-	defer r.Body.Close()
+	defer req.Body.Close()
 
 	// Won't bother logging the following errors as they are caused by bad/poor
 	// client requests, which we don't really care about on the server side.
-	f, err := Unpack(b, r.Header.Get("Content-Type"))
+	form, err := Unpack(body, req.Header.Get("Content-Type"))
 	if err != nil {
-		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+		http.Error(resp, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 		return
 	}
-	reg, ok := f.(*forms.MessengerRegistration_v1)
+	registration, ok := form.(*forms.MessengerRegistration_v1)
 	if !ok {
-		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+		http.Error(resp, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 		return
 	}
-	if len(reg.Host) < 1 {
-		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+	if len(registration.Host) < 1 {
+		http.Error(resp, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
 		return
 	}
 
-	s.Mutex.Lock()
-	defer s.Mutex.Unlock()
-	if _, found := s.Messengers[reg.Host]; found {
+	sys.Mutex.Lock()
+	defer sys.Mutex.Unlock()
+	if _, found := sys.Messengers[registration.Host]; found {
 		// The system already knows the messenger, avoid re-storing it so that
 		// the error count don't get reset
 		return
 	}
-	s.Messengers[reg.Host] = 0 // Registers the new messenger with zero errors
+	sys.Messengers[registration.Host] = 0 // Registers the new messenger with zero errors
 }
diff --git a/usecases/provision_test.go b/usecases/provision_test.go
index c5fbe7d..2b6817b 100644
--- a/usecases/provision_test.go
+++ b/usecases/provision_test.go
@@ -211,14 +211,14 @@ func TestRegisterMessenger(t *testing.T) {
 		},
 	}
 
-	s := components.NewSystem("testsys", context.Background())
+	sys := components.NewSystem("testsys", context.Background())
 	testFunc := func(method, content string, body io.ReadCloser) *http.Response {
-		w := httptest.NewRecorder()
-		r := httptest.NewRequest(method, "/msg", body)
-		r.Header.Set("Content-Type", content)
-		RegisterMessenger(w, r, &s)
+		rec := httptest.NewRecorder()
+		req := httptest.NewRequest(method, "/msg", body)
+		req.Header.Set("Content-Type", content)
+		RegisterMessenger(rec, req, &sys)
 
-		return w.Result()
+		return rec.Result()
 	}
 	for _, test := range table {
 		res := testFunc(test.method, test.contentType, test.body)
@@ -228,21 +228,21 @@ func TestRegisterMessenger(t *testing.T) {
 	}
 
 	// Verify the messenger was registered from the last test case
-	errors, found := s.Messengers[testMessenger]
+	errors, found := sys.Messengers[testMessenger]
 	if errors != 0 || found == false {
 		t.Errorf("expected registered messenger, found none")
 	}
 
 	// Verify duplicate registration doesn't lose error count
 	errCount := -1
-	s.Messengers[testMessenger] = errCount
+	sys.Messengers[testMessenger] = errCount
 	res := testFunc(http.MethodPost, "application/json",
 		io.NopCloser(strings.NewReader(testRegMesForm)),
 	)
 	if got, want := res.StatusCode, http.StatusOK; got != want {
 		t.Errorf("expected status %d, got %d", want, got)
 	}
-	if got, want := s.Messengers[testMessenger], errCount; got != want {
+	if got, want := sys.Messengers[testMessenger], errCount; got != want {
 		t.Errorf("expected error count %d, got %d", want, got)
 	}
 }

From 188b38c95549244014ffd96ac29f427ba1e7bbd8 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Fri, 25 Jul 2025 13:51:46 +0200
Subject: [PATCH 179/186] Motivates reason for not using timestamps in message
 form

---
 forms/message_forms.go | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/forms/message_forms.go b/forms/message_forms.go
index d73994c..56a494d 100644
--- a/forms/message_forms.go
+++ b/forms/message_forms.go
@@ -64,10 +64,13 @@ func LevelToString(lvl MessageLevel) string {
 
 // A SystemMessage is a log message sent from a system to one or many messengers.
 // The receiving messengers will note the message's time of arrival.
+// The timestamp is noted on the messenger side, so as to maintain a uniform
+// chronological order of the messages (if, for example, there exists systems
+// on other hosts with misconfigured time or timezone).
 type SystemMessage_v1 struct {
-	Level   MessageLevel `json:"level"`
-	Body    string       `json:"body"`
-	System  string       `json:"system"`
+	Level   MessageLevel `json:"level"`  // Severity level
+	Body    string       `json:"body"`   // Plaintext string of the actual message to be logged.
+	System  string       `json:"system"` // The system sending the log
 	Version string       `json:"version"`
 }
 

From ea4c7c4da9bd4448551bf53c53ccbdfae7c6d6c7 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 28 Jul 2025 14:01:01 +0200
Subject: [PATCH 180/186] Added an arbitrary timeout for the http.DefaultClient

---
 usecases/utilities.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/usecases/utilities.go b/usecases/utilities.go
index b073cde..3cc74ad 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -27,6 +27,7 @@ import (
 	"net/http"
 	"reflect"
 	"strings"
+	"time"
 	"unicode"
 
 	"github.com/sdoque/mbaigo/forms"
@@ -170,6 +171,7 @@ func sendHTTPReq(method string, url string, data []byte) (resp *http.Response, e
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json")
+	http.DefaultClient.Timeout = 30 * time.Second
 	resp, err = http.DefaultClient.Do(req)
 	if err != nil {
 		return nil, err

From f4783476b012889d20e3227277de4fd5601369b4 Mon Sep 17 00:00:00 2001
From: Pake <walpat-1@student.ltu.se>
Date: Mon, 28 Jul 2025 14:11:11 +0200
Subject: [PATCH 181/186] Added comment while setting the
 http.DefaultClient.Timeout

---
 usecases/utilities.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/usecases/utilities.go b/usecases/utilities.go
index 3cc74ad..f02f5c6 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -171,7 +171,7 @@ func sendHTTPReq(method string, url string, data []byte) (resp *http.Response, e
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json")
-	http.DefaultClient.Timeout = 30 * time.Second
+	http.DefaultClient.Timeout = 30 * time.Second // Arbitrarily set timeout
 	resp, err = http.DefaultClient.Do(req)
 	if err != nil {
 		return nil, err

From 6a3ffabfdde84bfbf1be72ba4506b54ecc3a04d6 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Mon, 28 Jul 2025 16:02:01 +0200
Subject: [PATCH 182/186] Completed tests for GetStates in
 usecases/consumption.go

---
 usecases/consumption.go      |  47 ++++----
 usecases/consumption_test.go | 202 +++++++++++++++++++++++++----------
 2 files changed, 174 insertions(+), 75 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index 1ee1fa3..209bb9f 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -35,7 +35,7 @@ func GetState(cer *components.Cervice, sys *components.System) (f forms.Form, er
 }
 
 // GetStates requests the current state of certain services of a unit asset depending on requested definition and/or details
-func GetStates(cer *components.Cervice, sys *components.System) (f []forms.Form, err error) {
+func GetStates(cer *components.Cervice, sys *components.System) (f []forms.Form, err []error) {
 	return stateHandlers(http.MethodGet, cer, sys, nil)
 }
 
@@ -82,57 +82,62 @@ func stateHandler(httpMethod string, cer *components.Cervice, sys *components.Sy
 	return Unpack(bodyBytes, headerContentType)
 }
 
-func stateHandlers(httpMethod string, cer *components.Cervice, sys *components.System, bodyBytes []byte) (f []forms.Form, err error) {
+func stateHandlers(httpMethod string, cer *components.Cervice, sys *components.System, bodyBytes []byte) (f []forms.Form, err []error) {
 	if len(cer.Nodes) == 0 {
-		err := Search4MultipleServices(cer, sys)
-		if err != nil {
+		lastErr := Search4MultipleServices(cer, sys)
+		if lastErr != nil {
+			f = append(f, nil)
+			err = append(err, lastErr)
 			return f, err
 		}
 	}
 
-	// Preallocate serviceUrl with the number of nodes
-	serviceUrls := make([]string, len(cer.Nodes))
-	index := 0
+	var serviceUrls []string
 	for _, values := range cer.Nodes {
 		if len(values) > 0 {
-			serviceUrls[index] = values[0]
+			serviceUrls = append(serviceUrls, values...)
 		}
-		index++
 	}
 
-	var lastErr error
-
 	for _, serviceUrl := range serviceUrls {
 		if len(serviceUrl) == 0 {
 			continue
 		}
-		resp, err := sendHttpReq(httpMethod, serviceUrl, bodyBytes)
-		if err != nil {
+		resp, lastErr := sendHttpReq(httpMethod, serviceUrl, bodyBytes)
+		if lastErr != nil {
 			cer.Nodes = make(map[string][]string)
-			lastErr = err
+			f = append(f, nil)
+			err = append(err, lastErr)
 			continue
 		}
 		defer resp.Body.Close()
 
 		// If the response includes a payload, unpack it into a forms.Form
-		bodyBytes, err = io.ReadAll(resp.Body)
-		if err != nil {
-			lastErr = fmt.Errorf("reading state response body: %w", err)
+		bodyBytes, lastErr = io.ReadAll(resp.Body)
+		if lastErr != nil {
+			lastErr = fmt.Errorf("reading state response body: %w", lastErr)
+			f = append(f, nil)
+			err = append(err, lastErr)
 			continue
 		}
 
 		if len(bodyBytes) < 1 {
 			lastErr = fmt.Errorf("got empty response body")
+			f = append(f, nil)
+			err = append(err, lastErr)
 			continue
 		}
 
 		headerContentType := resp.Header.Get("Content-Type")
-		formValue, err := Unpack(bodyBytes, headerContentType)
-		if err != nil {
-			lastErr = fmt.Errorf("unpacking response body: %w", err)
+		formValue, lastErr := Unpack(bodyBytes, headerContentType)
+		if lastErr != nil {
+			lastErr = fmt.Errorf("unpacking response body: %w", lastErr)
+			f = append(f, nil)
+			err = append(err, lastErr)
 			continue
 		}
 		f = append(f, formValue)
+		err = append(err, nil)
 	}
-	return f, lastErr
+	return f, err
 }
diff --git a/usecases/consumption_test.go b/usecases/consumption_test.go
index a7bb23d..106755b 100644
--- a/usecases/consumption_test.go
+++ b/usecases/consumption_test.go
@@ -3,6 +3,7 @@ package usecases
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
 	"log"
 	"net/http"
@@ -237,8 +238,20 @@ func TestSetState(t *testing.T) {
 	}
 }
 
-func createDoubleHttpRespWithServRecList() func() *http.Response {
-	f := createServiceRecordListTestForm()
+func createServRecListTestForm(amount int) (servRecList forms.ServiceRecordList_v1) {
+	servRecList.NewForm()
+	servRecList.List = make([]forms.ServiceRecord_v1, amount)
+	for i := range amount {
+		servRecList.List[i].IPAddresses = []string{"123.456.789"}
+		servRecList.List[i].ProtoPort = map[string]int{"http": 123}
+	}
+	return servRecList
+}
+
+// Use this one if a mock response from an orchestrator is needed
+func createDoubleHttpRespWithServRecList(amount int, empty bool, statusErr bool,
+	readErr bool, unpackErr bool) func() *http.Response {
+	f := createServRecListTestForm(amount)
 	// Create mock response from orchestrator
 	fakeBody, err := json.Marshal(f)
 	if err != nil {
@@ -246,82 +259,163 @@ func createDoubleHttpRespWithServRecList() func() *http.Response {
 	}
 	count := 0
 	return func() *http.Response {
-		count++
-		if count == 1 || count == 3 {
-			return &http.Response{
-				Status:     "200 OK",
-				StatusCode: 200,
-				Header:     http.Header{"Content-Type": []string{"application/json"}},
-				Body:       io.NopCloser(strings.NewReader(string(fakeBody))),
-			}
-		}
-		return &http.Response{
+		resp := &http.Response{
 			Status:     "200 OK",
 			StatusCode: 200,
 			Header:     http.Header{"Content-Type": []string{"application/json"}},
 			Body: io.NopCloser(strings.NewReader(string("{\n  \"value\": 0,\n  \"unit\": \"\",\n " +
 				" \"timestamp\": \"0001-01-01T00:00:00Z\",\n  \"version\": \"SignalA_v1.0\"\n}"))),
 		}
+		count++
+		if count == 1 {
+			resp.Body = io.NopCloser(strings.NewReader(string(fakeBody)))
+			return resp
+		}
+		if empty == true {
+			resp.Body = io.NopCloser(strings.NewReader(string("")))
+			return resp
+		}
+		if statusErr == true {
+			resp.Status = "300 NAK"
+			resp.StatusCode = 300
+			return resp
+		}
+		if readErr == true {
+			resp.Body = io.NopCloser(errorReader{})
+			return resp
+		}
+		if unpackErr == true {
+			resp.Header = http.Header{"Content-Type": []string{"Wrong content type"}}
+			return resp
+		}
+		return resp
+	}
+}
+
+func formsEqual(a, b []forms.Form) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] == nil && b[i] == nil {
+			continue
+		}
+		aForm, ok := a[i].(*forms.SignalA_v1a)
+		if !ok {
+			return false
+		}
+		bForm, ok := b[i].(*forms.SignalA_v1a)
+		if !ok {
+			return false
+		}
+		if aForm.Value != bForm.Value || aForm.Unit != bForm.Unit ||
+			aForm.Timestamp != bForm.Timestamp || aForm.Version != bForm.Version {
+			return false
+		}
+	}
+	return true
+}
+
+func errEqual(a, b []error) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if (a[i] != nil && b[i] == nil) || (a[i] == nil && b[i] != nil) {
+			return false
+		}
 	}
+	return true
 }
 
 type getStatesTestStruct struct {
-	testCer          *components.Cervice
-	bodyBytes        []byte
 	body             func() *http.Response
 	mockTransportErr int
 	errHTTP          error
-	expectedForm     forms.Form
-	expectedErr      error
+	expectedForm     []forms.Form
+	expectedErr      []error
 	testName         string
 }
 
+var (
+	threeForms    = []forms.Form{form.NewForm(), form.NewForm(), form.NewForm()}
+	oneNilForm    = []forms.Form{form.NewForm(), form.NewForm(), nil}
+	nilForms      = []forms.Form{nil, nil, nil}
+	singleNilForm = []forms.Form{nil}
+	threeErr      = []error{fmt.Errorf("Error"), fmt.Errorf("Error"), fmt.Errorf("Error")}
+	oneErr        = []error{nil, nil, fmt.Errorf("Error")}
+	nilErr        = []error{nil, nil, nil}
+	singleErr     = []error{fmt.Errorf("Error")}
+)
+
 var getStatesTestParams = []getStatesTestStruct{
-	{newTestCerviceWithNodes(), createTestBytes(), createWorkingHttpResp(), 0, nil, form.NewForm(),
-		nil, "No errors with nodes"},
-	{newTestCerviceWithoutNodes(), createTestBytes(), createDoubleHttpRespWithServRecList(), 0, nil, form.NewForm(),
-		nil, "No errors without nodes"},
-	{newTestCerviceWithNodes(), nil, createEmptyHttpResp(), 0, nil, nil,
-		errEmptyRespBody, "Empty response body error"},
-	{newTestCerviceWithoutNodes(), createTestBytes(), createWorkingHttpResp(), 1, errHTTP, nil,
-		errHTTP, "Search4Services error"},
-	{newTestCerviceWithBrokenUrl(), createTestBytes(), createWorkingHttpResp(), 2, errHTTP, nil,
-		errHTTP, "NewRequest() error"},
-	{newTestCerviceWithNodes(), createTestBytes(), createStatusErrorHttpResp(), 2, errHTTP, nil,
-		errHTTP, "Status code error"},
-	{newTestCerviceWithNodes(), createTestBytes(), createErrorReaderHttpResp(), 0, nil, nil,
-		errBodyRead, "io.ReadAll() error"},
-	{newTestCerviceWithNodes(), createTestBytes(), createUnpackErrorHttpResp(), 0, nil, nil,
-		errUnpack, "Unpack() error"},
-	{newTestCerviceWithNodes(), createTestBytes(), createWorkingHttpResp(), 1, errHTTP, nil,
-		errHTTP, "DefaultClient.Do() error"},
+	{createDoubleHttpRespWithServRecList(3, false, false, false, false), 0, nil, threeForms,
+		nilErr, "No errors without nodes"},
+	{createDoubleHttpRespWithServRecList(3, false, false, false, false), 4, errHTTP, oneNilForm,
+		oneErr, "Error in one of the services"},
+	{createDoubleHttpRespWithServRecList(3, true, false, false, false), 0, nil, nilForms,
+		threeErr, "Empty response body error"},
+	{createWorkingHttpResp(), 1, errHTTP, singleNilForm,
+		singleErr, "Search4Services error"},
+	{createDoubleHttpRespWithServRecList(3, false, true, false, false), 0, nil, nilForms,
+		threeErr, "Status code error"},
+	{createDoubleHttpRespWithServRecList(3, false, false, true, false), 0, nil, nilForms,
+		threeErr, "io.ReadAll() error"},
+	{createDoubleHttpRespWithServRecList(3, false, false, false, true), 0, nil, nilForms,
+		threeErr, "Unpack() error"},
 }
 
 func TestGetStates(t *testing.T) {
 	for _, testCase := range getStatesTestParams {
+		testCer := newTestCerviceWithoutNodes()
 		testSys := createTestSystem(false)
 		newMockTransport(testCase.body, testCase.mockTransportErr, testCase.errHTTP)
 
-		res, err := GetStates(testCase.testCer, &testSys)
-
-		if testCase.expectedForm != nil {
-			expected := testCase.expectedForm.(*forms.SignalA_v1a)
-			for _, form := range res {
-				actual, ok := form.(*forms.SignalA_v1a)
-				if !ok {
-					t.Fatalf("Test case: %s, got %v, expected a forms.Form",
-						testCase.testName, form,
-					)
-				}
-				if expected.Value != actual.Value || expected.Unit != actual.Unit ||
-					expected.Timestamp != actual.Timestamp || expected.Version != actual.Version ||
-					err != testCase.expectedErr {
-					t.Errorf("Test case: %s got error: %v. \nExpected form: \n%+v\n, got: \n%+v",
-						testCase.testName, err, expected, actual)
-				}
-			}
-		} else if err == nil {
-			t.Errorf("Test case: %s got error: %v:", testCase.testName, err)
+		res, err := GetStates(testCer, &testSys)
+
+		if !formsEqual(res, testCase.expectedForm) || !errEqual(err, testCase.expectedErr) {
+			t.Errorf("Test case: %s\nExpected forms: %+v\nGot: %+v\nExpected error: %v, Got error: %v",
+				testCase.testName, testCase.expectedForm, res, testCase.expectedErr, err)
 		}
 	}
+
+	// Special case: No errors with existing nodes
+	cerWithNodes := components.Cervice{
+		IReferentce: "test",
+		Definition:  "A test Cervice with nodes",
+		Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
+		Nodes:       map[string][]string{"test": {"test1", "test2", "test3"}},
+		Protos:      []string{"http"},
+	}
+	testSys := createTestSystem(false)
+	newMockTransport(createWorkingHttpResp(), 0, nil)
+
+	res, err := GetStates(&cerWithNodes, &testSys)
+	expectedForm := []forms.Form{form.NewForm(), form.NewForm(), form.NewForm()}
+	expectedErr := []error{nil, nil, nil}
+
+	if !formsEqual(res, expectedForm) || !errEqual(err, expectedErr) {
+		t.Errorf("Test case: No errors with nodes \nExpected forms: %v\nGot: %v\nExpected error: %v, Got error: %v",
+			expectedForm, res, expectedErr, err)
+	}
+
+	// Special case: Error with a broken url in nodes
+	cerWithBrokenUrlNode := components.Cervice{
+		IReferentce: "test",
+		Definition:  "A test Cervice with nodes",
+		Details:     map[string][]string{"Forms": {"SignalA_v1a"}},
+		Nodes:       map[string][]string{"test": {"test1", brokenUrl, "test3"}},
+		Protos:      []string{"http"},
+	}
+	testSys = createTestSystem(false)
+	newMockTransport(createWorkingHttpResp(), 0, nil)
+
+	res, err = GetStates(&cerWithBrokenUrlNode, &testSys)
+	expectedForm = []forms.Form{form.NewForm(), nil, form.NewForm()}
+	expectedErr = []error{nil, fmt.Errorf("Error"), nil}
+
+	if !formsEqual(res, expectedForm) || !errEqual(err, expectedErr) {
+		t.Errorf("Test case: Error with broken url \nExpected forms: %v\nGot: %v\nExpected error: %v, Got error: %v",
+			expectedForm, res, expectedErr, err)
+	}
 }

From d6cf7882f0dba7fd168d82ea52cf098051f9559f Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Tue, 29 Jul 2025 16:39:26 +0200
Subject: [PATCH 183/186] Finished the GetStates function

---
 usecases/consumption.go | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/usecases/consumption.go b/usecases/consumption.go
index 209bb9f..72ea00b 100644
--- a/usecases/consumption.go
+++ b/usecases/consumption.go
@@ -84,10 +84,10 @@ func stateHandler(httpMethod string, cer *components.Cervice, sys *components.Sy
 
 func stateHandlers(httpMethod string, cer *components.Cervice, sys *components.System, bodyBytes []byte) (f []forms.Form, err []error) {
 	if len(cer.Nodes) == 0 {
-		lastErr := Search4MultipleServices(cer, sys)
-		if lastErr != nil {
+		currentErr := Search4MultipleServices(cer, sys)
+		if currentErr != nil {
 			f = append(f, nil)
-			err = append(err, lastErr)
+			err = append(err, currentErr)
 			return f, err
 		}
 	}
@@ -103,37 +103,37 @@ func stateHandlers(httpMethod string, cer *components.Cervice, sys *components.S
 		if len(serviceUrl) == 0 {
 			continue
 		}
-		resp, lastErr := sendHttpReq(httpMethod, serviceUrl, bodyBytes)
-		if lastErr != nil {
+		resp, currentErr := sendHttpReq(httpMethod, serviceUrl, bodyBytes)
+		if currentErr != nil {
 			cer.Nodes = make(map[string][]string)
 			f = append(f, nil)
-			err = append(err, lastErr)
+			err = append(err, currentErr)
 			continue
 		}
 		defer resp.Body.Close()
 
 		// If the response includes a payload, unpack it into a forms.Form
-		bodyBytes, lastErr = io.ReadAll(resp.Body)
-		if lastErr != nil {
-			lastErr = fmt.Errorf("reading state response body: %w", lastErr)
+		bodyBytes, currentErr = io.ReadAll(resp.Body)
+		if currentErr != nil {
+			currentErr = fmt.Errorf("reading state response body: %w", currentErr)
 			f = append(f, nil)
-			err = append(err, lastErr)
+			err = append(err, currentErr)
 			continue
 		}
 
 		if len(bodyBytes) < 1 {
-			lastErr = fmt.Errorf("got empty response body")
+			currentErr = fmt.Errorf("got empty response body")
 			f = append(f, nil)
-			err = append(err, lastErr)
+			err = append(err, currentErr)
 			continue
 		}
 
 		headerContentType := resp.Header.Get("Content-Type")
-		formValue, lastErr := Unpack(bodyBytes, headerContentType)
-		if lastErr != nil {
-			lastErr = fmt.Errorf("unpacking response body: %w", lastErr)
+		formValue, currentErr := Unpack(bodyBytes, headerContentType)
+		if currentErr != nil {
+			currentErr = fmt.Errorf("unpacking response body: %w", currentErr)
 			f = append(f, nil)
-			err = append(err, lastErr)
+			err = append(err, currentErr)
 			continue
 		}
 		f = append(f, formValue)

From cfb37a16b97e85ee8678514ad73dfbd66f8bd268 Mon Sep 17 00:00:00 2001
From: gabaxh <gabriel.axheim@outlook.com>
Date: Wed, 30 Jul 2025 13:57:04 +0200
Subject: [PATCH 184/186] Cleaned up the test for search4MultipleServices in
 usecases/service_discovery.go

---
 usecases/service_discovery_test.go | 183 +++++++++++------------------
 1 file changed, 71 insertions(+), 112 deletions(-)

diff --git a/usecases/service_discovery_test.go b/usecases/service_discovery_test.go
index 0fd2d8c..7dc0822 100644
--- a/usecases/service_discovery_test.go
+++ b/usecases/service_discovery_test.go
@@ -522,126 +522,85 @@ func createMultiHttpRespWithServRecList(statusCode int, broken bool, allowedRead
 	}
 }
 
-type search4MultipleServicesParams struct {
-	expectError bool
-	setup       func() (*components.Cervice, components.System)
-	response    func() *http.Response
-	transport   func(func() *http.Response) *mockTransport
-	testCase    string
+func createUnpackErrorBody() func() *http.Response {
+	return func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"Error"}},
+			Body:       io.NopCloser(strings.NewReader(string(""))),
+		}
+	}
 }
 
-func TestSearch4MultipleServices(t *testing.T) {
-	params := []search4MultipleServicesParams{
-		{
-			false,
-			func() (cer *components.Cervice, sys components.System) {
-				sys = createTestSystem(false)
-				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-				return
-			},
-			createMultiHttpRespWithServRecList(200, false, 0),
-			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
-			"Best case, no errors",
-		},
-		{
-			true,
-			func() (cer *components.Cervice, sys components.System) {
-				sys = createTestSystem(false)
-				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-				return
-			},
-			createMultiHttpRespWithServRecList(200, false, 0),
-			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 1, errHTTP) },
-			"Bad case, GetRunningCoreSystemURL() returns error",
-		},
-		{
-			true,
-			func() (cer *components.Cervice, sys components.System) {
-				sys = createTestSystem(false)
-				for i, cs := range sys.CoreS {
-					if cs.Name == "orchestrator" {
-						(*sys.CoreS[i]).Url = ""
-					}
-				}
-				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-				return
-			},
-			createMultiHttpRespWithServRecList(200, false, 0),
-			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
-			"Bad case, Orchestrator url is empty",
-		},
-		{
-			true,
-			func() (cer *components.Cervice, sys components.System) {
-				sys = createTestSystem(false)
-				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-				return
-			},
-			createMultiHttpRespWithServRecList(200, false, 0),
-			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 1, errHTTP) },
-			"Bad case, sendHttpReq() returns an error",
-		},
-		{
-			true,
-			func() (cer *components.Cervice, sys components.System) {
-				sys = createTestSystem(false)
-				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-				return
-			},
-			createMultiHttpRespWithServRecList(200, true, 1),
-			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
-			"Bad case, error while reading body",
-		},
-		{
-			true,
-			func() (cer *components.Cervice, sys components.System) {
-				sys = createTestSystem(false)
-				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-				return
-			},
-			func() *http.Response {
-				return &http.Response{
-					Status:     "200 OK",
-					StatusCode: 200,
-					Header:     http.Header{"Content-Type": []string{"Error"}},
-					Body:       io.NopCloser(strings.NewReader(string(""))),
-				}
-			},
-			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
-			"Bad case, error during Unpack",
-		},
-		{
-			true,
-			func() (cer *components.Cervice, sys components.System) {
-				sys = createTestSystem(false)
-				cer = (*sys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
-				return
-			},
-			func() *http.Response {
-				return &http.Response{
-					Status:     "200 OK",
-					StatusCode: 200,
-					Header:     http.Header{"Content-Type": []string{"application/json"}},
-					Body:       io.NopCloser(strings.NewReader(string(`{"version":"SignalA_v1.0"}`))),
-				}
-			},
-			func(resp func() *http.Response) *mockTransport { return newMockTransport(resp, 0, nil) },
-			"Bad case, error during type conversion",
-		},
+func createTypeConversionErrorBody() func() *http.Response {
+	return func() *http.Response {
+		return &http.Response{
+			Status:     "200 OK",
+			StatusCode: 200,
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Body:       io.NopCloser(strings.NewReader(string(`{"version":"SignalA_v1.0"}`))),
+		}
 	}
+}
 
-	for _, c := range params {
+type search4MultipleServicesStruct struct {
+	expectError      bool
+	emptyUrl         bool
+	response         func() *http.Response
+	mockTransportErr int
+	errHTTP          error
+	testName         string
+}
+
+var search4MultipleServicesParams = []search4MultipleServicesStruct{
+	{false, false, createMultiHttpRespWithServRecList(200, false, 0), 0, nil,
+		"Best case, no errors",
+	},
+	{true, false, createMultiHttpRespWithServRecList(200, false, 0), 1, errHTTP,
+		"Bad case, GetRunningCoreSystemURL() returns error",
+	},
+	{true, true, createMultiHttpRespWithServRecList(200, false, 0), 0, nil,
+		"Bad case, Orchestrator url is empty",
+	},
+	{true, false, createMultiHttpRespWithServRecList(200, false, 0), 1, errHTTP,
+		"Bad case, sendHttpReq() returns an error",
+	},
+	{true, false, createMultiHttpRespWithServRecList(200, true, 1), 0, nil,
+		"Bad case, error while reading body",
+	},
+	{true, false, createUnpackErrorBody(), 0, nil,
+		"Bad case, error during Unpack",
+	},
+	{true, false, createTypeConversionErrorBody(), 0, nil,
+		"Bad case, error during type conversion",
+	},
+}
+
+func TestSearch4MultipleServices(t *testing.T) {
+
+	for _, testCase := range search4MultipleServicesParams {
 		// Setup
-		c.transport(c.response)
-		cer, sys := c.setup()
+		testSys := createTestSystem(false)
+		testCer := (*testSys.UAssets["testUnitAsset"]).GetCervices()["testCerv"]
+
+		if testCase.emptyUrl == true {
+			for i, cs := range testSys.CoreS {
+				if cs.Name == "orchestrator" {
+					(*testSys.CoreS[i]).Url = ""
+				}
+			}
+		}
+
+		newMockTransport(testCase.response, testCase.mockTransportErr, testCase.errHTTP)
 
 		// Test
-		err := Search4MultipleServices(cer, &sys)
-		if (c.expectError == false) && (err != nil) {
-			t.Errorf("Expected no errors in '%s', got: %v", c.testCase, err)
+		err := Search4MultipleServices(testCer, &testSys)
+		if (testCase.expectError == false) && (err != nil) {
+			t.Errorf("Expected no errors in '%s', got: %v", testCase.testName, err)
 		}
-		if (c.expectError == true) && (err == nil) {
-			t.Errorf("Expected errors in '%s'", c.testCase)
+		if (testCase.expectError == true) && (err == nil) {
+			t.Errorf("Expected errors in '%s'", testCase.testName)
 		}
 	}
 }

From 3a9f19cb80f4c97e9c5f0190309f53763d33ba72 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Wed, 6 Aug 2025 14:34:35 +0200
Subject: [PATCH 185/186] Fix mistyped json tag

---
 forms/service_forms.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/forms/service_forms.go b/forms/service_forms.go
index e7542a2..88b81e0 100644
--- a/forms/service_forms.go
+++ b/forms/service_forms.go
@@ -64,7 +64,7 @@ func init() {
 ///////////////////////////////////////////////////////////////////////////////
 
 type ServiceRecordList_v1 struct {
-	List    []ServiceRecord_v1 `list:"version"`
+	List    []ServiceRecord_v1 `json:"list"`
 	Version string             `json:"version"`
 }
 

From c1c03389e82fac24f767d0e393a7ce9a4ba96397 Mon Sep 17 00:00:00 2001
From: Alex <git@larus.se>
Date: Mon, 11 Aug 2025 11:55:02 +0200
Subject: [PATCH 186/186] Adds a global http.DefaultClient

---
 usecases/utilities.go | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/usecases/utilities.go b/usecases/utilities.go
index f02f5c6..b473fb3 100644
--- a/usecases/utilities.go
+++ b/usecases/utilities.go
@@ -165,19 +165,30 @@ func IsCamelCase(s string) bool {
 	return IsFirstLetterLower(s)
 }
 
-func sendHTTPReq(method string, url string, data []byte) (resp *http.Response, err error) {
+func init() {
+	// Sets up a new global client with better defaults
+	// (the tests depends on this client too, and sometimes
+	// replaces it with a mock).
+	http.DefaultClient = &http.Client{
+		Timeout: time.Second * 30,
+	}
+}
+
+const userAgent string = "mbaigo"
+
+func sendHTTPReq(method string, url string, data []byte) (*http.Response, error) {
 	req, err := http.NewRequest(method, url, bytes.NewBuffer(data))
 	if err != nil {
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json")
-	http.DefaultClient.Timeout = 30 * time.Second // Arbitrarily set timeout
-	resp, err = http.DefaultClient.Do(req)
+	req.Header.Set("User-Agent", userAgent)
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return nil, err
 	}
 	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
 		return nil, fmt.Errorf("bad response: %d %s", resp.StatusCode, resp.Status)
 	}
-	return
+	return resp, nil
 }