flucky/PKGBUILD
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix(test/logfile): valid temperatures

Browse Source
This commit is contained in:
Markus Pesch
2019-06-21 11:48:44 +02:00
parent a3a8cc6e51
commit 87475225bc
18 changed files with 185 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
pkg/logfile/csv.go
View File

@ -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()

22
pkg/logfile/errors.go
View File

@ -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")

20
pkg/logfile/json.go
View File

@ -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
}

90
pkg/logfile/json_test.go Normal file
View File

@ -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
}

31
pkg/logfile/logfile.go
View File

@ -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
}
}
}

8
pkg/logfile/logfile_test.go Normal file
View File

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

0
pkg/logfile/test/faultyTemperatures_01.json → pkg/logfile/test/json/faultyTemperatures_01.json
View File

0
pkg/logfile/test/faultyTemperatures_02.json → pkg/logfile/test/json/faultyTemperatures_02.json
View File

0
pkg/logfile/test/faultyTemperatures_03.json → pkg/logfile/test/json/faultyTemperatures_03.json
View File

1
pkg/logfile/test/faultyTemperatures_04.json → pkg/logfile/test/json/faultyTemperatures_04.json
View File

@ -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",

0
pkg/logfile/test/faultyTemperatures_05.json → pkg/logfile/test/json/faultyTemperatures_05.json
View File

0
pkg/logfile/test/validTemperatures_01.json → pkg/logfile/test/json/validTemperatures_01.json
View File

0
pkg/logfile/test/validTemperatures_02.json → pkg/logfile/test/json/validTemperatures_02.json
View File

19
pkg/logfile/utils.go
View File

@ -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
}
}
}

20
pkg/logfile/xml.go
View File

@ -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
}