sec/parse_env_test.go

796 lines
17 KiB
Go
Raw Normal View History

2019-09-17 18:39:37 +05:00
package sec
import (
// stdlib
"os"
"strconv"
"testing"
// other
"github.com/stretchr/testify/require"
)
func TestParseString(t *testing.T) {
type testStruct struct {
StringData string
}
os.Setenv("STRINGDATA", "test")
2019-09-17 18:39:37 +05:00
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
}
func TestParseBoolean(t *testing.T) {
testCases := []struct {
TestData string
ValidData bool
}{
{"1", true},
{"t", true},
{"T", true},
{"TRUE", true},
{"true", true},
{"True", true},
{"0", false},
{"f", false},
{"F", false},
{"FALSE", false},
{"false", false},
{"False", false},
{"not a boolean", false},
}
type testStruct struct {
BoolData bool
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("BOOLDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.BoolData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotBoolError bool
_, err2 := strconv.ParseBool(testCase.TestData)
if err2 != nil {
checkNotBoolError = true
}
if checkNotBoolError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
require.Equal(t, errNotBool, err1)
}
os.Unsetenv("BOOLDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseInt8(t *testing.T) {
testCases := []struct {
TestData string
ValidData int8
}{
{"0", 0},
{"1", 1},
{"2", 2},
{"-128", -128},
{"127", 127},
{"-129", 0},
{"128", 0},
{"not an integer", 0},
}
type testStruct struct {
IntData int8
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("INTDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.IntData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != int64(testCase.ValidData) {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotInt, err1)
}
if checkRangeError {
require.Equal(t, errNotInt8, err1)
}
}
os.Unsetenv("INTDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseInt16(t *testing.T) {
testCases := []struct {
TestData string
ValidData int16
}{
{"0", 0},
{"1", 1},
{"2", 2},
{"-32768", -32768},
{"32767", 32767},
{"-32770", 0},
{"32770", 0},
{"not an integer", 0},
}
type testStruct struct {
IntData int16
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("INTDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.IntData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != int64(testCase.ValidData) {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotInt, err1)
}
if checkRangeError {
require.Equal(t, errNotInt16, err1)
}
}
os.Unsetenv("INTDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseInt32(t *testing.T) {
testCases := []struct {
TestData string
ValidData int32
}{
{"0", 0},
{"1", 1},
{"2", 2},
{"-2147483648", -2147483648},
{"2147483647", 2147483647},
{"-2147483650", 0},
{"2147483650", 0},
{"not an integer", 0},
}
type testStruct struct {
IntData int32
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("INTDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.IntData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != int64(testCase.ValidData) {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotInt, err1)
}
if checkRangeError {
require.Equal(t, errNotInt32, err1)
}
}
os.Unsetenv("INTDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseInt64(t *testing.T) {
testCases := []struct {
TestData string
ValidData int64
}{
{"0", 0},
{"1", 1},
{"2", 2},
{"-9223372036854775808", -9223372036854775808},
{"9223372036854775807", 9223372036854775807},
{"-9223372036854775810", -9223372036854775808},
{"9223372036854775810", 9223372036854775807},
{"not an integer", 0},
}
type testStruct struct {
IntData int64
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("INTDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.IntData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != testCase.ValidData {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotInt, err1)
}
if checkRangeError {
require.Equal(t, errNotInt64, err1)
}
}
os.Unsetenv("INTDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseUint8(t *testing.T) {
testCases := []struct {
TestData string
ValidData uint8
}{
{"0", 0},
{"1", 1},
{"2", 2},
{"255", 255},
{"256", 0},
{"-1", 0},
{"not an integer", 0},
}
type testStruct struct {
UintData uint8
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("UINTDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.UintData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != uint64(testCase.ValidData) {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotUint, err1)
}
if checkRangeError {
require.Equal(t, errNotUint8, err1)
}
}
os.Unsetenv("UINTDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseUint16(t *testing.T) {
testCases := []struct {
TestData string
ValidData uint16
}{
{"0", 0},
{"1", 1},
{"2", 2},
{"65535", 65535},
{"65536", 0},
{"-1", 0},
{"not an integer", 0},
}
type testStruct struct {
UintData uint16
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("UINTDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.UintData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != uint64(testCase.ValidData) {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotUint, err1)
}
if checkRangeError {
require.Equal(t, errNotUint16, err1)
}
}
os.Unsetenv("UINTDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseUint32(t *testing.T) {
testCases := []struct {
TestData string
ValidData uint32
}{
{"0", 0},
{"1", 1},
{"2", 2},
{"4294967295", 4294967295},
{"4294967296", 0},
{"-1", 0},
{"not an integer", 0},
}
type testStruct struct {
UintData uint32
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("UINTDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.UintData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != uint64(testCase.ValidData) {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotUint, err1)
}
if checkRangeError {
require.Equal(t, errNotUint32, err1)
}
}
os.Unsetenv("UINTDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseUint64(t *testing.T) {
testCases := []struct {
TestData string
ValidData uint64
}{
{"0", 0},
{"1", 1},
{"2", 2},
{"18446744073709551615", 18446744073709551615},
{"18446744073709551616", 18446744073709551615},
{"-1", 0},
{"not an integer", 0},
}
type testStruct struct {
UintData uint64
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("UINTDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.UintData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != testCase.ValidData {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotUint, err1)
}
if checkRangeError {
require.Equal(t, errNotUint64, err1)
}
}
os.Unsetenv("UINTDATA")
2019-09-17 18:39:37 +05:00
}
}
// Next tests should be improved.
func TestParseFloat32(t *testing.T) {
testCases := []struct {
TestData string
ValidData float32
}{
{"0.00", 0.00},
{"1.00", 1.00},
{"2.00", 2.00},
{"-1", -1},
{"not a float", 0.00},
}
type testStruct struct {
FloatData float32
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("FLOATDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.FloatData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseFloat(testCase.TestData, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != float64(testCase.ValidData) {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotFloat, err1)
}
if checkRangeError {
require.Equal(t, errNotFloat32, err1)
}
}
os.Unsetenv("FLOATDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseFloat64(t *testing.T) {
testCases := []struct {
TestData string
ValidData float64
}{
{"0.00", 0.00},
{"1.00", 1.00},
{"2.00", 2.00},
{"-1", -1},
{"not a float", 0.00},
}
type testStruct struct {
FloatData float64
}
for _, testCase := range testCases {
t.Logf("Testing: %+v", testCase)
os.Setenv("FLOATDATA", testCase.TestData)
2019-09-17 18:39:37 +05:00
// If ErrorsAreCritical == false, then we should check only
// equality of parsed data and valid data.
s := &testStruct{}
err := Parse(s, nil)
if err != nil {
t.Log(err.Error())
}
require.Nil(t, err)
require.Equal(t, testCase.ValidData, s.FloatData)
// If errors are critical - we should check if test data is within
// int8 range and check for error if it isn't.
s1 := &testStruct{}
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
var checkNotIntError bool
var checkRangeError bool
passedData, err2 := strconv.ParseFloat(testCase.TestData, 64)
if err2 != nil {
checkNotIntError = true
}
if passedData != testCase.ValidData {
checkRangeError = true
}
if checkNotIntError || checkRangeError {
if err1 == nil {
t.Log("No error returned!")
}
require.NotNil(t, err1)
if checkNotIntError {
require.Equal(t, errNotFloat, err1)
}
if checkRangeError {
require.Equal(t, errNotFloat64, err1)
}
}
os.Unsetenv("FLOATDATA")
2019-09-17 18:39:37 +05:00
}
}
func TestParseStructWithInterfaceFields(t *testing.T) {
type testStruct struct {
Data interface{}
}
os.Setenv(debugFlagEnvName, "true")
testCase := &testStruct{}
testCase.Data = 0
os.Setenv("DATA", "64")
err := Parse(testCase, nil)
require.Nil(t, err)
require.NotEqual(t, 64, testCase.Data)
testCase1 := &testStruct{}
d := 0
shouldBeRaw := 64
shouldBe := &shouldBeRaw
testCase1.Data = &d
err1 := Parse(testCase1, nil)
require.Nil(t, err1)
require.Equal(t, (*shouldBe), (*testCase1.Data.(*int)))
os.Unsetenv("DATA")
os.Unsetenv(debugFlagEnvName)
}
func TestParseStructWitStructAsInterface(t *testing.T) {
type testStruct struct {
Data interface{}
Int int
}
type testUnderlyingStruct struct {
Data string
}
os.Setenv(debugFlagEnvName, "true")
os.Setenv("INT", "64")
os.Setenv("DATA_DATA", "Test data")
testCase := &testStruct{}
testUnderlyingCase := &testUnderlyingStruct{}
testCase.Data = testUnderlyingCase
err := Parse(testCase, nil)
require.Nil(t, err)
require.Equal(t, testCase.Int, 64)
require.Equal(t, testCase.Data.(*testUnderlyingStruct).Data, "Test data")
os.Unsetenv("INT")
os.Unsetenv("DATA_DATA")
os.Unsetenv(debugFlagEnvName)
}