Merge pull request #13 from FireTail-io/tests

Improve Firetail Package Test Coverage

Author: TheTeaCat

firetail/extract_firetail_records_test.go

@@ -1,9 +1,12 @@
 package firetail
 
 import (
+	"encoding/base32"
 	"encoding/base64"
 	"encoding/json"
+	"firetail-lambda-extension/logsapi"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -26,3 +29,170 @@ func TestDecodeFiretailRecordResponse(t *testing.T) {
 
 	assert.Equal(t, testRecord.Response, *&decodedRecord.Response)
 }
+
+func TestDecodeFiretailRecordWithMissingPart(t *testing.T) {
+	encodedRecord := "firetail:log-ext"
+
+	decodedRecord, err := decodeFiretailRecord(encodedRecord)
+	assert.Nil(t, decodedRecord)
+	require.NotNil(t, err)
+
+	assert.Equal(t, "record had 2 parts when split by ':'", err.Error())
+}
+
+func TestDecodeFiretailRecordWithExtraPart(t *testing.T) {
+	testRecord := Record{
+		Response: RecordResponse{
+			StatusCode: 200,
+			Body:       "Test Body",
+		},
+	}
+	testPayloadBytes, err := json.Marshal(testRecord)
+	require.Nil(t, err)
+
+	encodedRecord := "firetail:log-ext:" + base64.StdEncoding.EncodeToString(testPayloadBytes) + ":extra"
+
+	decodedRecord, err := decodeFiretailRecord(encodedRecord)
+	assert.Nil(t, decodedRecord)
+	require.NotNil(t, err)
+
+	assert.Equal(t, "record had 4 parts when split by ':'", err.Error())
+}
+
+func TestDecodeFiretailRecordWithInvalidPrefix(t *testing.T) {
+	testRecord := Record{
+		Response: RecordResponse{
+			StatusCode: 200,
+			Body:       "Test Body",
+		},
+	}
+	testPayloadBytes, err := json.Marshal(testRecord)
+	require.Nil(t, err)
+
+	encodedRecord := "tailfire:log-ext:" + base64.StdEncoding.EncodeToString(testPayloadBytes)
+
+	decodedRecord, err := decodeFiretailRecord(encodedRecord)
+	assert.Nil(t, decodedRecord)
+	require.NotNil(t, err)
+
+	assert.Equal(t, "record did not have firetail prefix", err.Error())
+}
+
+func TestDecodeFiretailRecordWithInvalidToken(t *testing.T) {
+	testRecord := Record{
+		Response: RecordResponse{
+			StatusCode: 200,
+			Body:       "Test Body",
+		},
+	}
+	testPayloadBytes, err := json.Marshal(testRecord)
+	require.Nil(t, err)
+
+	encodedRecord := "firetail:ext-log:" + base64.StdEncoding.EncodeToString(testPayloadBytes)
+
+	decodedRecord, err := decodeFiretailRecord(encodedRecord)
+	assert.Nil(t, decodedRecord)
+	require.NotNil(t, err)
+
+	assert.Equal(t, "firetail prefixed record did not have valid token", err.Error())
+}
+
+func TestDecodeFiretailRecordWithInvalidPayloadEncoding(t *testing.T) {
+	testRecord := Record{
+		Response: RecordResponse{
+			StatusCode: 200,
+			Body:       "Test Body",
+		},
+	}
+	testPayloadBytes, err := json.Marshal(testRecord)
+	require.Nil(t, err)
+
+	encodedRecord := "firetail:log-ext:" + base32.StdEncoding.EncodeToString(testPayloadBytes)
+
+	decodedRecord, err := decodeFiretailRecord(encodedRecord)
+	assert.Nil(t, decodedRecord)
+	require.NotNil(t, err)
+
+	assert.Contains(t, err.Error(), "failed to b64 decode firetail record")
+}
+
+func TestDecodeFiretailRecordWithInvalidPayloadTypes(t *testing.T) {
+	type Event struct {
+		Event         string `json:"event"`
+		Response      int    `json:"response"`
+		ExecutionTime string `json:"execution_time"`
+	}
+	testRecord := Event{
+		Event:         "my birthday party",
+		Response:      0,
+		ExecutionTime: "tomorrow",
+	}
+	testPayloadBytes, err := json.Marshal(testRecord)
+	require.Nil(t, err)
+
+	encodedRecord := "firetail:log-ext:" + base64.StdEncoding.EncodeToString(testPayloadBytes)
+
+	decodedRecord, err := decodeFiretailRecord(encodedRecord)
+	assert.Nil(t, decodedRecord)
+	require.NotNil(t, err)
+
+	assert.Contains(t, err.Error(), "failed to unmarshal firetail event")
+}
+
+func TestExtractSingleRecord(t *testing.T) {
+	testRecord := Record{
+		Response: RecordResponse{
+			StatusCode: 200,
+			Body:       "Test Body",
+		},
+	}
+	testPayloadBytes, err := json.Marshal(testRecord)
+	require.Nil(t, err)
+	encodedRecord := "firetail:log-ext:" + base64.StdEncoding.EncodeToString(testPayloadBytes)
+
+	testMessage := logsapi.LogMessage{
+		Time:   time.Now().Format("2006-01-02T15:04:05.000Z"),
+		Type:   "function",
+		Record: json.RawMessage{},
+	}
+	testRecordBytes, err := json.Marshal(encodedRecord)
+	require.Nil(t, err)
+	testMessage.Record = testRecordBytes
+
+	decodedRecords, err := ExtractFiretailRecords([]logsapi.LogMessage{testMessage})
+	require.Nil(t, err)
+
+	require.Len(t, decodedRecords, 1)
+	assert.Equal(t, testRecord.Response, decodedRecords[0].Response)
+}
+
+func TestExtractRecordOfInvalidType(t *testing.T) {
+	testMessage := logsapi.LogMessage{
+		Type: "platform.start",
+	}
+
+	decodedRecords, err := ExtractFiretailRecords([]logsapi.LogMessage{testMessage})
+	require.NotNil(t, err)
+
+	assert.Len(t, decodedRecords, 0)
+	assert.Contains(t, err.Error(), "logMessage type is 'platform.start', not 'function'")
+}
+
+func TestExtractRecordWithInvalidType(t *testing.T) {
+	invalidRecord := 3.14159
+	testMessage := logsapi.LogMessage{
+		Time:   time.Now().Format("2006-01-02T15:04:05.000Z"),
+		Type:   "function",
+		Record: json.RawMessage{},
+	}
+	testRecordBytes, err := json.Marshal(invalidRecord)
+	require.Nil(t, err)
+	testMessage.Record = testRecordBytes
+
+	decodedRecords, err := ExtractFiretailRecords([]logsapi.LogMessage{testMessage})
+	require.NotNil(t, err)
+
+	assert.Len(t, decodedRecords, 0)
+	assert.Contains(t, err.Error(), "Err unmarshalling event record as string, err: json: cannot unmarshal number into Go value of type string")
+	assert.Contains(t, err.Error(), "Err decoding event record as firetail event, err: record had 1 parts when split by ':'")
+}

firetail/log_entry_test.go

@@ -0,0 +1,46 @@
+package firetail
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEncodeAndDecodeLogEntry(t *testing.T) {
+	testLogEntry := LogEntry{
+		DateCreated:   time.Now().UnixMilli(),
+		ExecutionTime: 50,
+		Request: LogEntryRequest{
+			Body: "{\"Description\":\"This is a test request body\"}",
+			Headers: map[string][]string{
+				"Test-Request-Header": {"Test-Value-1", "Test-Value-2"},
+			},
+			HTTPProtocol: HTTP2,
+			IP:           "8.8.8.8",
+			Method:       Get,
+			URI:          "https://www.example.com/pets/100",
+			Resource:     "/pets/{id}",
+		},
+		Response: LogEntryResponse{
+			Body: "{\"Description\":\"This is a test response body\"}",
+			Headers: map[string][]string{
+				"Test-Response-Header": {"Test-Value-1", "Test-Value-2"},
+			},
+			StatusCode: 200,
+		},
+		Version: The100Alpha,
+	}
+
+	testLogEntryBytes, err := testLogEntry.Marshal()
+	require.Nil(t, err)
+
+	unmarshalledLogEntry, err := UnmarshalLogEntry(testLogEntryBytes)
+	require.Nil(t, err)
+	assert.Equal(t, testLogEntry, unmarshalledLogEntry)
+
+	remarshalledLogEntryBytes, err := unmarshalledLogEntry.Marshal()
+	require.Nil(t, err)
+	assert.Equal(t, testLogEntryBytes, remarshalledLogEntryBytes)
+}

firetail/record.go

@@ -39,7 +39,9 @@ func (r *Record) getLogEntryRequest() (*LogEntryRequest, int64, error) {
 
 	var apiGatewayV1Request events.APIGatewayProxyRequest
 	apiGatewayV1RequestErr := json.Unmarshal(r.Event, &apiGatewayV1Request)
-	if apiGatewayV1RequestErr == nil {
+	// If there was no err in unmarshalling into an events.APIGatewayProxyRequest, and the HTTPMethod was populated with a non-zero value, we will
+	// assume it's an events.APIGatewayProxyRequest.
+	if apiGatewayV1RequestErr == nil && apiGatewayV1Request.Resource != "" {
 		logEntryRequest := &LogEntryRequest{
 			Body:         apiGatewayV1Request.Body,
 			Headers:      apiGatewayV1Request.MultiValueHeaders,