fix(test/logfile): valid temperatures

pkg/logfile/csv.go

@@ -21,21 +21,21 @@ func (cl *csvLogfile) GetLogfile() string {
 
 func (cl *csvLogfile) ReadHumidities() ([]*types.Humidity, error) {
 	if _, err := os.Stat(cl.logfile); os.IsNotExist(err) {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileNotFound, cl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileNotFound, cl.logfile)
 	}
 
 	humidities := make([]*types.Humidity, 0)
 
 	f, err := os.Open(cl.logfile)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileOpen, cl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileOpen, cl.logfile)
 	}
 	defer f.Close()
 
 	jsonDecoder := json.NewDecoder(f)
 	err = jsonDecoder.Decode(&humidities)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileDecode, err)
+		return nil, fmt.Errorf("%v: %v", errorLogfileDecode, err)
 	}
 
 	return humidities, nil
@@ -43,21 +43,21 @@ func (cl *csvLogfile) ReadHumidities() ([]*types.Humidity, error) {
 
 func (cl *csvLogfile) ReadTemperatures() ([]*types.Temperature, error) {
 	if _, err := os.Stat(cl.logfile); os.IsNotExist(err) {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileNotFound, cl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileNotFound, cl.logfile)
 	}
 
 	temperatures := make([]*types.Temperature, 0)
 
 	f, err := os.Open(cl.logfile)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileOpen, cl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileOpen, cl.logfile)
 	}
 	defer f.Close()
 
 	r := csv.NewReader(f)
 	records, err := r.ReadAll()
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileDecode, cl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileDecode, cl.logfile)
 	}
 
 	for _, record := range records {
@@ -65,14 +65,14 @@ func (cl *csvLogfile) ReadTemperatures() ([]*types.Temperature, error) {
 		for _, j := range []int{2, 3} {
 			time, err := time.Parse(timeFormat, record[j])
 			if err != nil {
-				return nil, fmt.Errorf("%v: %v", ErrParseTime, record[j])
+				return nil, fmt.Errorf("%v: %v", errorParseTime, record[j])
 			}
 			times = append(times, time)
 		}
 
 		temperatureValue, err := strconv.ParseFloat(record[1], 64)
 		if err != nil {
-			return nil, fmt.Errorf("%v: %v", ErrParseFloat, record[1])
+			return nil, fmt.Errorf("%v: %v", errorParseFloat, record[1])
 		}
 
 		temperature := &types.Temperature{
@@ -86,7 +86,7 @@ func (cl *csvLogfile) ReadTemperatures() ([]*types.Temperature, error) {
 		if len(record) == 6 && record[5] != "" {
 			temperatureCreationDate, err := time.Parse(timeFormat, record[5])
 			if err != nil {
-				return nil, fmt.Errorf("%v: %v", ErrParseTime, record[5])
+				return nil, fmt.Errorf("%v: %v", errorParseTime, record[5])
 			}
 
 			temperature.CreationDate = &temperatureCreationDate
@@ -95,7 +95,7 @@ func (cl *csvLogfile) ReadTemperatures() ([]*types.Temperature, error) {
 		if len(record) == 7 && record[6] != "" {
 			temperatureUpdateDate, err := time.Parse(timeFormat, record[6])
 			if err != nil {
-				return nil, fmt.Errorf("%v: %v", ErrParseTime, record[6])
+				return nil, fmt.Errorf("%v: %v", errorParseTime, record[6])
 			}
 
 			temperature.UpdateDate = &temperatureUpdateDate
@@ -111,7 +111,7 @@ func (cl *csvLogfile) WriteHumidities(humidities []*types.Humidity) error {
 
 	f, err := os.Create(cl.logfile)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogileCreate, cl.logfile)
+		return fmt.Errorf("%v: %v", errorLogfileCreate, cl.logfile)
 	}
 	defer f.Close()
 
@@ -137,7 +137,7 @@ func (cl *csvLogfile) WriteHumidities(humidities []*types.Humidity) error {
 func (cl *csvLogfile) WriteTemperatures(temperatures []*types.Temperature) error {
 	f, err := os.Create(cl.logfile)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogileCreate, cl.logfile)
+		return fmt.Errorf("%v: %v", errorLogfileCreate, cl.logfile)
 	}
 	defer f.Close()
 

pkg/logfile/errors.go

@@ -2,10 +2,18 @@ package logfile
 
 import "errors"
 
-var ErrLogfileNotFound = errors.New("Can not find logfile")
-var ErrLogileCreate = errors.New("Can not create logfile")
-var ErrLogfileDecode = errors.New("Can not decode from reader")
-var ErrLogfileEncode = errors.New("Cano not encode from writer")
-var ErrLogfileOpen = errors.New("Can not open logfile")
-var ErrParseFloat = errors.New("Can not parse float")
-var ErrParseTime = errors.New("Can not parse time")
+var errorLogfileNotFound = errors.New("Can not find logfile")
+var errorLogfileCreate = errors.New("Can not create logfile")
+var errorLogfileDecode = errors.New("Can not decode from reader")
+var errorLogfileEncode = errors.New("Can not encode from writer")
+var errorLogfileOpen = errors.New("Can not open logfile")
+
+var errorParseFloat = errors.New("Can not parse float")
+var errorParseTime = errors.New("Can not parse time")
+
+var errorNoValidHumidityID = errors.New("No valid humidity id detected or available")
+var errorNoValidMesuredValue = errors.New("No mesured value detected or available")
+var errorNoValidSensorID = errors.New("No sensor id detected or available")
+var errorNoValidTemperatureID = errors.New("No valid temperature id detected or available")
+var errorNoValidTime = errors.New("No time detected or available")
+var errorNoValidTimePeriods = errors.New("No valid time periods")

pkg/logfile/json.go

@@ -18,21 +18,21 @@ func (jl *jsonLogfile) GetLogfile() string {
 
 func (jl *jsonLogfile) ReadHumidities() ([]*types.Humidity, error) {
 	if _, err := os.Stat(jl.logfile); os.IsNotExist(err) {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileNotFound, jl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileNotFound, jl.logfile)
 	}
 
 	humidities := make([]*types.Humidity, 0)
 
 	f, err := os.Open(jl.logfile)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileOpen, jl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileOpen, jl.logfile)
 	}
 	defer f.Close()
 
 	jsonDecoder := json.NewDecoder(f)
 	err = jsonDecoder.Decode(&humidities)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileDecode, err)
+		return nil, fmt.Errorf("%v: %v", errorLogfileDecode, err)
 	}
 
 	return humidities, nil
@@ -40,21 +40,21 @@ func (jl *jsonLogfile) ReadHumidities() ([]*types.Humidity, error) {
 
 func (jl *jsonLogfile) ReadTemperatures() ([]*types.Temperature, error) {
 	if _, err := os.Stat(jl.logfile); os.IsNotExist(err) {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileNotFound, jl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileNotFound, jl.logfile)
 	}
 
 	temperatures := make([]*types.Temperature, 0)
 
 	f, err := os.Open(jl.logfile)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileOpen, jl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileOpen, jl.logfile)
 	}
 	defer f.Close()
 
 	jsonDecoder := json.NewDecoder(f)
 	err = jsonDecoder.Decode(&temperatures)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileDecode, err)
+		return nil, fmt.Errorf("%v: %v", errorLogfileDecode, err)
 	}
 
 	return temperatures, nil
@@ -64,7 +64,7 @@ func (jl *jsonLogfile) WriteHumidities(humidities []*types.Humidity) error {
 
 	f, err := os.Create(jl.logfile)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogileCreate, jl.logfile)
+		return fmt.Errorf("%v: %v", errorLogfileCreate, jl.logfile)
 	}
 	defer f.Close()
 
@@ -72,7 +72,7 @@ func (jl *jsonLogfile) WriteHumidities(humidities []*types.Humidity) error {
 	jsonEncoder.SetIndent("", "  ")
 	err = jsonEncoder.Encode(humidities)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogfileEncode, err)
+		return fmt.Errorf("%v: %v", errorLogfileEncode, err)
 	}
 	return nil
 }
@@ -80,7 +80,7 @@ func (jl *jsonLogfile) WriteHumidities(humidities []*types.Humidity) error {
 func (jl *jsonLogfile) WriteTemperatures(temperatures []*types.Temperature) error {
 	f, err := os.Create(jl.logfile)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogileCreate, jl.logfile)
+		return fmt.Errorf("%v: %v", errorLogfileCreate, jl.logfile)
 	}
 	defer f.Close()
 
@@ -90,7 +90,7 @@ func (jl *jsonLogfile) WriteTemperatures(temperatures []*types.Temperature) erro
 	jsonEncoder.SetIndent("", "  ")
 	err = jsonEncoder.Encode(temperatures)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogfileEncode, err)
+		return fmt.Errorf("%v: %v", errorLogfileEncode, err)
 	}
 	return nil
 }

pkg/logfile/json_test.go

@@ -0,0 +1,90 @@
+package logfile_test
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/go-flucky/flucky/pkg/logfile"
+	"github.com/go-flucky/flucky/pkg/types"
+	uuid "github.com/satori/go.uuid"
+	"github.com/stretchr/testify/require"
+)
+
+var tmpDir string
+
+func TestJSON(t *testing.T) {
+	require := require.New(t)
+
+	tmpDir = filepath.Join(os.TempDir(), uuid.NewV4().String())
+	err := os.MkdirAll(tmpDir, 0775)
+	require.Nil(err)
+
+	testCases := []*testCase{
+		&testCase{
+			name: "validateTemperatures",
+			f:    testValidateTemperatures,
+		},
+	}
+
+	for _, testCase := range testCases {
+		err := t.Run(testCase.name, testCase.f)
+		require.True(err)
+	}
+}
+
+// func testCompressTemperatures(t *testing.T) {
+// 	require := require.New(t)
+
+// 	assets := []string{
+// 		"pkg/logfile/test/json/faultyTemperatures_01.json",
+// 		"pkg/logfile/test/json/faultyTemperatures_02.json",
+// 		"pkg/logfile/test/json/faultyTemperatures_03.json",
+// 		"pkg/logfile/test/json/faultyTemperatures_04.json",
+// 		"pkg/logfile/test/json/faultyTemperatures_05.json",
+// 	}
+
+// 	for i, asset := range assets {
+// 		l := filepath.Join(tmpDir, fmt.Sprintf("%v.json", i))
+// 		temperatures, err := saveAndReadTemperatureAsset(t, logfile.New(l), asset)
+// 		require.Nil(err, "%v", err)
+
+// 	}
+
+// }
+
+func testValidateTemperatures(t *testing.T) {
+	require := require.New(t)
+
+	assets := []string{
+		"pkg/logfile/test/json/faultyTemperatures_01.json",
+		"pkg/logfile/test/json/faultyTemperatures_02.json",
+		"pkg/logfile/test/json/faultyTemperatures_03.json",
+		"pkg/logfile/test/json/faultyTemperatures_04.json",
+		"pkg/logfile/test/json/faultyTemperatures_05.json",
+	}
+
+	for i, asset := range assets {
+		l := filepath.Join(tmpDir, fmt.Sprintf("%v.json", i))
+		temperatures, err := saveAndReadTemperatureAsset(t, logfile.New(l), asset)
+		require.Nil(err, "%v", err)
+
+		err = logfile.ValidateTemperatures(temperatures)
+		require.Errorf(err, "Asset %v", asset)
+	}
+}
+
+func saveAndReadTemperatureAsset(t *testing.T, logfile logfile.Logfile, a string) ([]*types.Temperature, error) {
+	require := require.New(t)
+
+	f, err := os.Create(logfile.GetLogfile())
+	require.Nil(err)
+	f.Write(MustAsset(a))
+	f.Close()
+
+	temperatures, err := logfile.ReadTemperatures()
+	require.Nil(err, "%v", err)
+
+	return temperatures, nil
+}

pkg/logfile/logfile.go

@@ -3,12 +3,16 @@ package logfile
 import (
 	"os"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"time"
 
 	"github.com/go-flucky/flucky/pkg/types"
 )
 
+var validUUID = regexp.MustCompile("^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-4[a-fA-F0-9]{3}-[8|9|aA|bB][a-fA-F0-9]{3}-[a-fA-F0-9]{12}$")
+var timeFormat = "2006-01-02 15:04:05.999999999 -0700"
+
 // AppendTemperatures with temperature values from a logfile. As additional option it's possible to compress the temperature data.
 func AppendTemperatures(logfile Logfile, compression bool, temperatures []*types.Temperature) error {
 
@@ -124,3 +128,30 @@ func SortTemperatures(temperatures []*types.Temperature) {
 		return temperatures[i].TemperatureFromDate.Before(temperatures[j].TemperatureFromDate)
 	})
 }
+
+func ValidateTemperatures(temperatures []*types.Temperature) error {
+	for _, temperature := range temperatures {
+		if !validUUID.MatchString(temperature.TemperatureID) {
+			return errorNoValidTemperatureID
+		} else if temperature.TemperatureValue == 0 {
+			return errorNoValidMesuredValue
+		} else if temperature.TemperatureFromDate.After(temperature.TemperatureTillDate) {
+			return errorNoValidTimePeriods
+		} else if !validUUID.MatchString(temperature.SensorID) {
+			return errorNoValidSensorID
+		} else if temperature.CreationDate.After(*temperature.UpdateDate) && temperature.UpdateDate != nil {
+			return errorNoValidTimePeriods
+		}
+	}
+
+	return nil
+}
+
+func writeCreationDate(temperatures []*types.Temperature) {
+	now := time.Now()
+	for _, temperature := range temperatures {
+		if temperature.CreationDate == nil {
+			temperature.CreationDate = &now
+		}
+	}
+}

pkg/logfile/logfile_test.go

@@ -0,0 +1,8 @@
+package logfile_test
+
+import "testing"
+
+type testCase struct {
+	name string
+	f    func(t *testing.T)
+}

pkg/logfile/test/json/faultyTemperatures_04.json

@@ -1,7 +1,6 @@
 [
   {
    "temperature_id": "a469503b-fc16-4e72-8d29-7eeee08ba957",
-   "temperature_value": "",
    "temperature_from_date": "2019-05-01T00:00:00.000000000+02:00",
    "temperature_till_date": "2019-10-01T00:00:00.000000000+02:00",
    "sensor_id": "84eac248-6927-4db6-b6f9-7891ce2d301e",

pkg/logfile/utils.go

@@ -1,19 +0,0 @@
-package logfile
-
-import (
-	"time"
-
-	"github.com/go-flucky/flucky/pkg/types"
-)
-
-//.999999999 -0700 MST
-var timeFormat = "2006-01-02 15:04:05.999999999 -0700"
-
-func writeCreationDate(temperatures []*types.Temperature) {
-	now := time.Now()
-	for _, temperature := range temperatures {
-		if temperature.CreationDate == nil {
-			temperature.CreationDate = &now
-		}
-	}
-}

pkg/logfile/xml.go

@@ -18,21 +18,21 @@ func (xl *xmlLogfile) GetLogfile() string {
 
 func (xl *xmlLogfile) ReadHumidities() ([]*types.Humidity, error) {
 	if _, err := os.Stat(xl.logfile); os.IsNotExist(err) {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileNotFound, xl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileNotFound, xl.logfile)
 	}
 
 	humidities := make([]*types.Humidity, 0)
 
 	f, err := os.Open(xl.logfile)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileOpen, xl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileOpen, xl.logfile)
 	}
 	defer f.Close()
 
 	xmlDecoder := xml.NewDecoder(f)
 	err = xmlDecoder.Decode(&humidities)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileDecode, err)
+		return nil, fmt.Errorf("%v: %v", errorLogfileDecode, err)
 	}
 
 	return humidities, nil
@@ -40,21 +40,21 @@ func (xl *xmlLogfile) ReadHumidities() ([]*types.Humidity, error) {
 
 func (xl *xmlLogfile) ReadTemperatures() ([]*types.Temperature, error) {
 	if _, err := os.Stat(xl.logfile); os.IsNotExist(err) {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileNotFound, xl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileNotFound, xl.logfile)
 	}
 
 	temperatures := make([]*types.Temperature, 0)
 
 	f, err := os.Open(xl.logfile)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileOpen, xl.logfile)
+		return nil, fmt.Errorf("%v: %v", errorLogfileOpen, xl.logfile)
 	}
 	defer f.Close()
 
 	xmlDecoder := xml.NewDecoder(f)
 	err = xmlDecoder.Decode(&temperatures)
 	if err != nil {
-		return nil, fmt.Errorf("%v: %v", ErrLogfileDecode, err)
+		return nil, fmt.Errorf("%v: %v", errorLogfileDecode, err)
 	}
 
 	return temperatures, nil
@@ -64,7 +64,7 @@ func (xl *xmlLogfile) WriteHumidities(humidities []*types.Humidity) error {
 
 	f, err := os.Create(xl.logfile)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogileCreate, xl.logfile)
+		return fmt.Errorf("%v: %v", errorLogfileCreate, xl.logfile)
 	}
 	defer f.Close()
 
@@ -72,7 +72,7 @@ func (xl *xmlLogfile) WriteHumidities(humidities []*types.Humidity) error {
 	xmlEncoder.Indent("", "  ")
 	err = xmlEncoder.Encode(humidities)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogfileEncode, err)
+		return fmt.Errorf("%v: %v", errorLogfileEncode, err)
 	}
 	return nil
 }
@@ -80,7 +80,7 @@ func (xl *xmlLogfile) WriteHumidities(humidities []*types.Humidity) error {
 func (xl *xmlLogfile) WriteTemperatures(temperatures []*types.Temperature) error {
 	f, err := os.Create(xl.logfile)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogileCreate, xl.logfile)
+		return fmt.Errorf("%v: %v", errorLogfileCreate, xl.logfile)
 	}
 	defer f.Close()
 
@@ -90,7 +90,7 @@ func (xl *xmlLogfile) WriteTemperatures(temperatures []*types.Temperature) error
 	xmlEncoder.Indent("", "  ")
 	err = xmlEncoder.Encode(temperatures)
 	if err != nil {
-		return fmt.Errorf("%v: %v", ErrLogfileEncode, err)
+		return fmt.Errorf("%v: %v", errorLogfileEncode, err)
 	}
 	return nil
 }