sec/parse_env_test.go

741 lines
16 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("TESTSTRUCT_STRINGDATA", "test")
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("TESTSTRUCT_BOOLDATA", testCase.TestData)
// 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("TESTSTRUCT_BOOLDATA")
}
}
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("TESTSTRUCT_INTDATA", testCase.TestData)
// 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("TESTSTRUCT_INTDATA")
}
}
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("TESTSTRUCT_INTDATA", testCase.TestData)
// 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("TESTSTRUCT_INTDATA")
}
}
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("TESTSTRUCT_INTDATA", testCase.TestData)
// 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("TESTSTRUCT_INTDATA")
}
}
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("TESTSTRUCT_INTDATA", testCase.TestData)
// 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("TESTSTRUCT_INTDATA")
}
}
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("TESTSTRUCT_UINTDATA", testCase.TestData)
// 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("TESTSTRUCT_UINTDATA")
}
}
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("TESTSTRUCT_UINTDATA", testCase.TestData)
// 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("TESTSTRUCT_UINTDATA")
}
}
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("TESTSTRUCT_UINTDATA", testCase.TestData)
// 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("TESTSTRUCT_UINTDATA")
}
}
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("TESTSTRUCT_UINTDATA", testCase.TestData)
// 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("TESTSTRUCT_UINTDATA")
}
}
// 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("TESTSTRUCT_FLOATDATA", testCase.TestData)
// 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("TESTSTRUCT_FLOATDATA")
}
}
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("TESTSTRUCT_FLOATDATA", testCase.TestData)
// 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("TESTSTRUCT_FLOATDATA")
}
}
// Float