Merge pull request #8 from deploymenttheory/dev-jl-testing

Implemented Unit testing for non web dependant functions

Author: thejoeker12

jamf/jamfprointegration/auth_mock.go

@@ -39,50 +39,41 @@ type OAuthResponse struct {
 
 // getNewToken updates the held token and expiry information
 func (a *oauth) getNewToken() error {
-	a.Sugar.Warn("THREE-TWO-ONE")
 	data := url.Values{}
 	data.Set("client_id", a.clientId)
 	data.Set("client_secret", a.clientSecret)
 	data.Set("grant_type", "client_credentials")
 
-	a.Sugar.Warn("THREE-TWO-TWO")
 	oauthComlpeteEndpoint := a.baseDomain + oAuthTokenEndpoint
 	a.Sugar.Debugf("oauth endpoint constructed: %s", oauthComlpeteEndpoint)
 
-	a.Sugar.Warn("THREE-TWO-THREE")
 	req, err := http.NewRequest("POST", oauthComlpeteEndpoint, strings.NewReader(data.Encode()))
 	if err != nil {
 		return err
 	}
-	a.Sugar.Warn("THREE-TWO-FOUR")
 
 	a.Sugar.Debugf("oauth token request constructed: %+v", req)
 
 	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
 
-	a.Sugar.Warn("THREE-TWO-FIVE")
 	resp, err := a.httpExecutor.Do(req)
 	if err != nil {
 		return err
 	}
-	a.Sugar.Warn("THREE-TWO-SIX")
 
 	if resp.StatusCode < 200 || resp.StatusCode > 299 {
 		return fmt.Errorf("bad request getting auth token: %v", resp)
 	}
 
 	defer resp.Body.Close()
 
-	a.Sugar.Warn("THREE-TWO-SEVEN")
 	bodyBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return err
 	}
-	a.Sugar.Warn("THREE-TWO-EIGHT")
 
 	resp.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
 
-	a.Sugar.Warn("THREE-TWO-NINE")
 	oauthResp := &OAuthResponse{}
 	err = json.Unmarshal(bodyBytes, oauthResp)
 	if err != nil {

jamf/jamfprointegration/auth_oauth.go

@@ -8,12 +8,12 @@ import (
 )
 
 // BuildWithOAuth is a helper function allowing the full construct of a Jamf Integration using OAuth2
-func BuildWithOAuth(jamfBaseDomain string, Sugar *zap.SugaredLogger, bufferPeriod time.Duration, clientId string, clientSecret string, hideSensitiveData bool, executor *httpclient.HTTPExecutor) (*Integration, error) {
+func BuildWithOAuth(jamfBaseDomain string, Sugar *zap.SugaredLogger, bufferPeriod time.Duration, clientId string, clientSecret string, hideSensitiveData bool, executor httpclient.HTTPExecutor) (*Integration, error) {
 	integration := Integration{
 		BaseDomain:           jamfBaseDomain,
 		Sugar:                Sugar,
 		AuthMethodDescriptor: "oauth2",
-		httpExecutor:         *executor,
+		httpExecutor:         executor,
 	}
 
 	integration.BuildOAuth(clientId, clientSecret, bufferPeriod, hideSensitiveData, executor)
@@ -23,13 +23,13 @@ func BuildWithOAuth(jamfBaseDomain string, Sugar *zap.SugaredLogger, bufferPerio
 }
 
 // BuildWithBasicAuth is a helper function allowing the full construct of a Jamf Integration using BasicAuth
-func BuildWithBasicAuth(jamfBaseDomain string, Sugar *zap.SugaredLogger, bufferPeriod time.Duration, username string, password string, hideSensitiveData bool, executor *httpclient.HTTPExecutor) (*Integration, error) {
+func BuildWithBasicAuth(jamfBaseDomain string, Sugar *zap.SugaredLogger, bufferPeriod time.Duration, username string, password string, hideSensitiveData bool, executor httpclient.HTTPExecutor) (*Integration, error) {
 
 	integration := Integration{
 		BaseDomain:           jamfBaseDomain,
 		Sugar:                Sugar,
 		AuthMethodDescriptor: "basic",
-		httpExecutor:         *executor,
+		httpExecutor:         executor,
 	}
 
 	integration.BuildBasicAuth(username, password, bufferPeriod, hideSensitiveData, executor)
@@ -39,30 +39,30 @@ func BuildWithBasicAuth(jamfBaseDomain string, Sugar *zap.SugaredLogger, bufferP
 }
 
 // BuildOAuth is a helper which returns just a configured OAuth interface
-func (j *Integration) BuildOAuth(clientId string, clientSecret string, bufferPeriod time.Duration, hideSensitiveData bool, executor *httpclient.HTTPExecutor) {
+func (j *Integration) BuildOAuth(clientId string, clientSecret string, bufferPeriod time.Duration, hideSensitiveData bool, executor httpclient.HTTPExecutor) {
 	authInterface := oauth{
 		clientId:          clientId,
 		clientSecret:      clientSecret,
 		bufferPeriod:      bufferPeriod,
 		baseDomain:        j.BaseDomain,
 		Sugar:             j.Sugar,
 		hideSensitiveData: hideSensitiveData,
-		httpExecutor:      *executor,
+		httpExecutor:      executor,
 	}
 
 	j.auth = &authInterface
 }
 
 // BuildBasicAuth is a helper which returns just a configured Basic Auth interface/
-func (j *Integration) BuildBasicAuth(username string, password string, bufferPeriod time.Duration, hideSensitiveData bool, executor *httpclient.HTTPExecutor) {
+func (j *Integration) BuildBasicAuth(username string, password string, bufferPeriod time.Duration, hideSensitiveData bool, executor httpclient.HTTPExecutor) {
 	authInterface := basicAuth{
 		username:          username,
 		password:          password,
 		bufferPeriod:      bufferPeriod,
 		Sugar:             j.Sugar,
 		baseDomain:        j.BaseDomain,
 		hideSensitiveData: hideSensitiveData,
-		httpExecutor:      *executor,
+		httpExecutor:      executor,
 	}
 
 	j.auth = &authInterface

jamf/jamfprointegration/builders.go

@@ -6,6 +6,25 @@ import (
 	"go.uber.org/zap"
 )
 
+const (
+	WeightedAcceptHeader = "application/x-x509-ca-cert;q=0.95," +
+		"application/pkix-cert;q=0.94," +
+		"application/pem-certificate-chain;q=0.93," +
+		"application/octet-stream;q=0.8," + // For general binary files
+		"image/png;q=0.75," +
+		"image/jpeg;q=0.74," +
+		"image/*;q=0.7," +
+		"application/xml;q=0.65," +
+		"text/xml;q=0.64," +
+		"text/xml;charset=UTF-8;q=0.63," +
+		"application/json;q=0.5," +
+		"text/html;q=0.5," +
+		"text/plain;q=0.4," +
+		"*/*;q=0.05"
+
+	UserAgentHeader = "go-api-http-client-jamfpro-integration"
+)
+
 // getContentTypeHeader determines the appropriate Content-Type header for a given API endpoint.
 // It sets the Content-Type to "application/octet-stream" specifically for the endpoint "/api/v1/packages/{id}/upload".
 // For other endpoints, it attempts to match the Content-Type based on the endpoint pattern:
@@ -16,13 +35,15 @@ import (
 func (j *Integration) getContentTypeHeader(endpoint string) string {
 	j.Sugar.Debug("Determining Content-Type for endpoint", zap.String("endpoint", endpoint))
 
+	// TODO change this contains to regex. We want to rule out malformed endpoints with multiple occurances.
 	if strings.Contains(endpoint, "/api/v1/packages/") && strings.Contains(endpoint, "/upload") {
 		j.Sugar.Debugw("Content-Type for packages upload endpoint set to application/octet-stream", "endpoint", endpoint)
 		return "application/octet-stream"
 	}
 
 	if strings.Contains(endpoint, "/JSSResource") {
 		j.Sugar.Debugw("Content-Type for endpoint defaulting to XML for Classic API", "endpoint", endpoint)
+		// TODO should this be application/xml or text/xml?
 		return "application/xml"
 	}
 
@@ -43,25 +64,10 @@ func (j *Integration) getContentTypeHeader(endpoint string) string {
 // indicating a preference for XML. The specified MIME types cover common content formats like
 // images, JSON, XML, HTML, plain text, and certificates, with a fallback option for all other types.
 func (j *Integration) getAcceptHeader() string {
-	weightedAcceptHeader := "application/x-x509-ca-cert;q=0.95," +
-		"application/pkix-cert;q=0.94," +
-		"application/pem-certificate-chain;q=0.93," +
-		"application/octet-stream;q=0.8," + // For general binary files
-		"image/png;q=0.75," +
-		"image/jpeg;q=0.74," +
-		"image/*;q=0.7," +
-		"application/xml;q=0.65," +
-		"text/xml;q=0.64," +
-		"text/xml;charset=UTF-8;q=0.63," +
-		"application/json;q=0.5," +
-		"text/html;q=0.5," +
-		"text/plain;q=0.4," +
-		"*/*;q=0.05" // Fallback for any other types
-
-	return weightedAcceptHeader
+	return WeightedAcceptHeader
 }
 
 // getUserAgentHeader returns the User-Agent header string for the Jamf Pro API.
 func (j *Integration) getUserAgentHeader() string {
-	return "go-api-http-client-jamfpro-integration"
+	return UserAgentHeader
 }

jamf/jamfprointegration/headers.go

@@ -0,0 +1,124 @@
+package jamfprointegration
+
+import (
+	"testing"
+)
+
+func TestIntegration_getContentTypeHeader(t *testing.T) {
+	testIntegration := newIntegrationWithLogger()
+	type fields struct {
+		integration Integration
+	}
+	type args struct {
+		endpoint string
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   string
+	}{
+		{
+			name: "packages endpoint",
+			fields: fields{
+				integration: testIntegration,
+			},
+			args: args{
+				endpoint: "http://yourserver.jamfcloud.com/api/v1/packages/upload/something else",
+			},
+			want: "application/octet-stream",
+		},
+		{
+			name: "classic endpoint",
+			fields: fields{
+				integration: testIntegration,
+			},
+			args: args{
+				endpoint: "http://yourserver.jamfcloud.com/JSSResource/somethingelse",
+			},
+			want: "application/xml",
+		},
+		{
+			name: "pro endpoint",
+			fields: fields{
+				integration: testIntegration,
+			},
+			args: args{
+				endpoint: "http://yourserver.jamfcloud.com/api/v100/cheeseburger",
+			},
+			want: "application/json",
+		},
+		{
+			name: "unrecognised endpoint",
+			fields: fields{
+				integration: testIntegration,
+			},
+			args: args{
+				endpoint: "http://yourserver.jamfcloud.com/spaghetti",
+			},
+			want: "application/json",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			j := tt.fields.integration
+			if got := j.getContentTypeHeader(tt.args.endpoint); got != tt.want {
+				t.Errorf("Integration.getContentTypeHeader() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIntegration_getAcceptHeader(t *testing.T) {
+	type fields struct {
+		integration Integration
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "singular",
+			fields: fields{
+				integration: Integration{},
+			},
+			want: WeightedAcceptHeader,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			j := tt.fields.integration
+			if got := j.getAcceptHeader(); got != tt.want {
+				t.Errorf("Integration.getAcceptHeader() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIntegration_getUserAgentHeader(t *testing.T) {
+	type fields struct {
+		integration Integration
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "singular",
+			fields: fields{
+				integration: Integration{},
+			},
+			want: UserAgentHeader,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			j := tt.fields.integration
+			if got := j.getUserAgentHeader(); got != tt.want {
+				t.Errorf("Integration.getUserAgentHeader() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

jamf/jamfprointegration/headers_test.go

@@ -0,0 +1,45 @@
+package jamfprointegration
+
+import (
+	"testing"
+)
+
+func Test_chooseMostAlphabeticalString(t *testing.T) {
+	type args struct {
+		strings []string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "easy test - abc vs def and xyz",
+			args: args{
+				strings: []string{"abc", "def", "xyz"},
+			},
+			want: "abc",
+		},
+		{
+			name: "ignore numbers",
+			args: args{
+				strings: []string{"123a", "jjj", "zzz"},
+			},
+			want: "123a",
+		},
+		{
+			name: "hard test - azz vs rrs and byz",
+			args: args{
+				strings: []string{"byz", "rrs", "azz"},
+			},
+			want: "azz",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := chooseMostAlphabeticalString(tt.args.strings); got != tt.want {
+				t.Errorf("chooseMostAlphabeticalString() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}