table_test.go

package golium

import (
	"context"
	"errors"
	"testing"

	"github.com/cucumber/godog"
	"github.com/stretchr/testify/require"
)

var (
	withoutHeaders       = [][]string{{"John", "182"}}
	withoutHeadersValues = [][]string{{"John", "182"}, {"Doe", "190"}}
	withName             = [][]string{{"name"}, {"John"}}
	withNameAndHeight    = [][]string{{"name", "height"}, {"John", "182"}}
	withNameHeightAndAge = [][]string{{"name", "height", "age"}, {"John", "182", "32"}}
	withParamAndValue    = [][]string{{"param", "value"}, {"Name", "182"}, {"Height", "162"}}
	withNameAndValue     = [][]string{{"Name", "Value"}, {"example 1", "1"}, {"example 2", "10"}}
)

type Headers struct {
	Name   string
	Height string
}

func TestRemoveHeaders(t *testing.T) {
	tcs := []struct {
		name        string
		table       *godog.Table
		expectedErr error
	}{
		{
			name:  "Remove header expected error",
			table: NewTable(withoutHeaders),
			expectedErr: errors.New(
				"cannot remove header: table must have at least one header and one useful row"),
		},
		{
			name:        "Remove header table ok",
			table:       NewTable(withNameAndHeight),
			expectedErr: nil,
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			// Call the tested function
			err := RemoveHeaders(tc.table)

			// Check expected behavior
			if err != nil && err.Error() != tc.expectedErr.Error() {
				t.Errorf("Expected error: %s, Error received: %s", tc.expectedErr, err)
			}

			if tc.expectedErr == nil && err != nil {
				t.Errorf("Expected error: %s, Error received: %s", tc.expectedErr, err)
			}
		})
	}
}

func TestColumnsChecker(t *testing.T) {
	tcs := []struct {
		name        string
		table       *godog.Table
		n           int
		expectedErr error
	}{
		{
			name:  "Check columns less than n",
			table: NewTable(withName),
			n:     2,
			expectedErr: errors.New(
				"table must have 2 columns"),
		},
		{
			name:  "Check columns more than n",
			table: NewTable(withNameHeightAndAge),
			n:     2,
			expectedErr: errors.New(
				"table must have 2 columns"),
		},
		{
			name:        "Check columns ok",
			table:       NewTable(withNameAndHeight),
			n:           2,
			expectedErr: nil,
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			// Call the tested function
			err := ColumnsChecker(tc.table.Rows[0].Cells, tc.n)

			// Check expected behavior
			if err != nil && err.Error() != tc.expectedErr.Error() {
				t.Errorf("Expected error: %s, Error received: %s", tc.expectedErr, err)
			}

			if tc.expectedErr == nil && err != nil {
				t.Errorf("Expected error: %s, Error received: %s", tc.expectedErr, err)
			}
		})
	}
}

func TestConvertTableToMap(t *testing.T) {
	expectedResult := make(map[string]interface{})
	expectedResult["John"] = "182"
	tcs := []struct {
		name           string
		table          *godog.Table
		expectedResult interface{}
		expectedErr    error
	}{
		{
			name:           "Convert table to map ok",
			table:          NewTable(withNameAndHeight),
			expectedResult: expectedResult,
			expectedErr:    nil,
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			ctx := context.Background()
			// Call the tested function
			convertedTable, err := ConvertTableToMap(ctx, tc.table)

			require.Equal(t, tc.expectedErr, err)
			require.Equal(t, tc.expectedResult, convertedTable)
		})
	}
}

func TestConvertTableColumnToArray(t *testing.T) {
	expectedResult := []string{}
	expectedResult = append(expectedResult, "John")
	tcs := []struct {
		name           string
		table          *godog.Table
		expectedResult interface{}
		expectedErr    error
	}{
		{
			name:           "Convert table column to array ok",
			table:          NewTable(withName),
			expectedResult: expectedResult,
			expectedErr:    nil,
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			ctx := context.Background()
			// Call the tested function
			convertedTable, err := ConvertTableColumnToArray(ctx, tc.table)

			require.Equal(t, tc.expectedErr, err)
			require.Equal(t, tc.expectedResult, convertedTable)
		})
	}
}

func TestConvertTableToMultiMap(t *testing.T) {
	expectedResult := make(map[string][]string)
	expectedResult["John"] = []string{"182"}
	tcs := []struct {
		name           string
		table          *godog.Table
		expectedResult interface{}
		expectedErr    error
	}{
		{
			name:           "Convert table to multi map ok",
			table:          NewTable(withNameAndHeight),
			expectedResult: expectedResult,
			expectedErr:    nil,
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			ctx := context.Background()
			// Call the tested function
			convertedTable, err := ConvertTableToMultiMap(ctx, tc.table)

			require.Equal(t, tc.expectedErr, err)
			require.Equal(t, tc.expectedResult, convertedTable)
		})
	}
}

func TestConvertTableWithoutHeaderToStruct(t *testing.T) {
	tcs := []struct {
		name        string
		table       *godog.Table
		expectedErr error
	}{
		{
			name:        "Convert table wo header to struct ok",
			table:       NewTable(withParamAndValue),
			expectedErr: nil,
		},
		{
			name:  "Convert table wo header to struct fail",
			table: NewTable(withNameAndHeight),
			expectedErr: errors.New("failed setting element 'John' in struct of type " +
				"'golium.Headers': field 'John' is not valid"),
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			ctx := context.Background()
			var props Headers
			// Call the tested function
			err := ConvertTableWithoutHeaderToStruct(ctx, tc.table, &props)

			require.Equal(t, tc.expectedErr, err)
		})
	}
}

func TestConvertTableWithHeaderToStructSlice(t *testing.T) {
	type TestElement struct {
		Name  string
		Value int
	}
	testSlice := []TestElement{}

	tcs := []struct {
		name    string
		table   *godog.Table
		wantErr bool
	}{
		{
			name:    "Convert table with header to struct ok",
			table:   NewTable(withNameAndValue),
			wantErr: false,
		},
		{
			name:    "Convert table without header to struct fail",
			table:   NewTable(withoutHeadersValues),
			wantErr: true,
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			ctx := context.Background()
			if err := ConvertTableWithHeaderToStructSlice(
				ctx, tc.table, &testSlice); (err != nil) != tc.wantErr {
				t.Errorf(
					"ConvertTableWithHeaderToStructSlice() error = %v, wantErr %v", err, tc.wantErr)
			}
		})
	}
}