go-trustlog/api/model/validation_test.go

package model_test

import (
	"testing"

	"github.com/stretchr/testify/assert"

	"go.yandata.net/iod/iod/go-trustlog/api/model"
)

func TestValidationResult_IsProcessing(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		code     int32
		expected bool
	}{
		{
			name:     "processing code",
			code:     model.ValidationCodeProcessing,
			expected: true,
		},
		{
			name:     "completed code",
			code:     model.ValidationCodeCompleted,
			expected: false,
		},
		{
			name:     "failed code",
			code:     model.ValidationCodeFailed,
			expected: false,
		},
		{
			name:     "other code",
			code:     99,
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			v := &model.ValidationResult{Code: tt.code}
			assert.Equal(t, tt.expected, v.IsProcessing())
		})
	}
}

func TestValidationResult_IsCompleted(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		code     int32
		expected bool
	}{
		{
			name:     "processing code",
			code:     model.ValidationCodeProcessing,
			expected: false,
		},
		{
			name:     "completed code",
			code:     model.ValidationCodeCompleted,
			expected: true,
		},
		{
			name:     "failed code",
			code:     model.ValidationCodeFailed,
			expected: false,
		},
		{
			name:     "other code",
			code:     99,
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			v := &model.ValidationResult{Code: tt.code}
			assert.Equal(t, tt.expected, v.IsCompleted())
		})
	}
}

func TestValidationResult_IsFailed(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		code     int32
		expected bool
	}{
		{
			name:     "processing code",
			code:     model.ValidationCodeProcessing,
			expected: false,
		},
		{
			name:     "completed code",
			code:     model.ValidationCodeCompleted,
			expected: false,
		},
		{
			name:     "failed code",
			code:     model.ValidationCodeFailed,
			expected: true,
		},
		{
			name:     "code greater than failed",
			code:     501,
			expected: true,
		},
		{
			name:     "code less than failed",
			code:     499,
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			v := &model.ValidationResult{Code: tt.code}
			assert.Equal(t, tt.expected, v.IsFailed())
		})
	}
}

func TestRecordValidationResult_IsProcessing(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		code     int32
		expected bool
	}{
		{
			name:     "processing code",
			code:     model.ValidationCodeProcessing,
			expected: true,
		},
		{
			name:     "completed code",
			code:     model.ValidationCodeCompleted,
			expected: false,
		},
		{
			name:     "failed code",
			code:     model.ValidationCodeFailed,
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			r := &model.RecordValidationResult{Code: tt.code}
			assert.Equal(t, tt.expected, r.IsProcessing())
		})
	}
}

func TestRecordValidationResult_IsCompleted(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		code     int32
		expected bool
	}{
		{
			name:     "processing code",
			code:     model.ValidationCodeProcessing,
			expected: false,
		},
		{
			name:     "completed code",
			code:     model.ValidationCodeCompleted,
			expected: true,
		},
		{
			name:     "failed code",
			code:     model.ValidationCodeFailed,
			expected: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			r := &model.RecordValidationResult{Code: tt.code}
			assert.Equal(t, tt.expected, r.IsCompleted())
		})
	}
}

func TestRecordValidationResult_IsFailed(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name     string
		code     int32
		expected bool
	}{
		{
			name:     "processing code",
			code:     model.ValidationCodeProcessing,
			expected: false,
		},
		{
			name:     "completed code",
			code:     model.ValidationCodeCompleted,
			expected: false,
		},
		{
			name:     "failed code",
			code:     model.ValidationCodeFailed,
			expected: true,
		},
		{
			name:     "code greater than failed",
			code:     501,
			expected: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			r := &model.RecordValidationResult{Code: tt.code}
			assert.Equal(t, tt.expected, r.IsFailed())
		})
	}
}