data.TestIntegerGenerator_GenerateDataBySchema_GivenSchemaAndRandomValue_ExpectedValue - Code Metrics - muonsoft/openapi-mock - Measure and Improve Code Quality continuously with Scrutinizer

maAndRandomValue_ExpectedValue B
last analyzed 2023-03-11 09:18 UTC

↳ Parent: internal/openapi/generator/data/integerGenerator_test.go

Complexity

Conditions

Size

Total Lines	103
Code Lines	76

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	76
nop	1
dl	0
loc	103
rs	7.7854
c	0
b	0
f	0

How to fix Long Method

package data

import (
	"context"
	"testing"

	"github.com/getkin/kin-openapi/openapi3"
	"github.com/stretchr/testify/assert"
)

const (
	testDefaultMinInt int64 = 0
	testDefaultMaxInt int64 = 12345
)

func TestIntegerGenerator_GenerateDataBySchema_GivenSchemaAndRandomValue_ExpectedValue(t *testing.T) {
	min := 10.0
	max := 100.0

	tests := []struct {
		name             string
		schema           *openapi3.Schema
		randomValue      int64
		expectedMaxValue int64
		expectedValue    int64
	}{
		{
			"no params, min random value",
			openapi3.NewSchema(),
			0,
			testDefaultMaxInt + 1,
			0,
		},
		{
			"no params, max random value",
			openapi3.NewSchema(),
			testDefaultMaxInt,
			testDefaultMaxInt + 1,
			testDefaultMaxInt,
		},
		{
			"given range, min random value",
			&openapi3.Schema{
				Min: &min,
				Max: &max,
			},
			0,
			91,
			10,
		},
		{
			"given range, max random value",
			&openapi3.Schema{
				Min: &min,
				Max: &max,
			},
			90,
			91,
			100,
		},
		{
			"given exclusive range, min random value",
			&openapi3.Schema{
				Min:          &min,
				Max:          &max,
				ExclusiveMin: true,
				ExclusiveMax: true,
			},
			0,
			89,
			11,
		},
		{
			"given exclusive range, max random value",
			&openapi3.Schema{
				Min:          &min,
				Max:          &max,
				ExclusiveMin: true,
				ExclusiveMax: true,
			},
			88,
			89,
			99,
		},
		{
			"32bit format, min random value",
			&openapi3.Schema{
				Format: "int32",
			},
			0,
			testDefaultMaxInt + 1,
			0,
		},
		{
			"multiple of, random value",
			&openapi3.Schema{
				MultipleOf: &min,
			},
			17,
			testDefaultMaxInt + 1,
			10,
		},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			randomMock := &mockRandomGenerator{}
			integerGeneratorInstance := &integerGenerator{
				random:         randomMock,
				defaultMinimum: testDefaultMinInt,
				defaultMaximum: testDefaultMaxInt,
			}
			randomMock.On("Int63n", test.expectedMaxValue).Return(test.randomValue).Once()

			data, err := integerGeneratorInstance.GenerateDataBySchema(context.Background(), test.schema)

			randomMock.AssertExpectations(t)
			assert.NoError(t, err)
			assert.Equal(t, test.expectedValue, data)
		})
	}
}

func TestIntegerGenerator_GenerateDataBySchema_MaxLessThanMin_Error(t *testing.T) {
	integerGeneratorInstance := &integerGenerator{}
	min := 11.0
	max := 10.0
	schema := openapi3.NewSchema()
	schema.Min = &min
	schema.Max = &max

	data, err := integerGeneratorInstance.GenerateDataBySchema(context.Background(), schema)

	assert.EqualError(t, err, "[integerGenerator] maximum cannot be less than minimum")
	assert.Equal(t, 0, data)
}

func TestIntegerGenerator_GenerateDataBySchema_MaxEqualToMin_StaticValue(t *testing.T) {
	integerGeneratorInstance := &integerGenerator{}
	min := 10.0
	max := 10.0
	schema := openapi3.NewSchema()
	schema.Min = &min
	schema.Max = &max

	data, err := integerGeneratorInstance.GenerateDataBySchema(context.Background(), schema)

	assert.NoError(t, err)
	assert.Equal(t, int64(10), data)
}


1			package data
2
3			import (
4			"context"
5			"testing"
6
7			"github.com/getkin/kin-openapi/openapi3"
8			"github.com/stretchr/testify/assert"
9			)
10
11			const (
12			testDefaultMinInt int64 = 0
13			testDefaultMaxInt int64 = 12345
14			)
15
16			func TestIntegerGenerator_GenerateDataBySchema_GivenSchemaAndRandomValue_ExpectedValue(t *testing.T) {
17			min := 10.0
18			max := 100.0
19
20			tests := []struct {
21			name string
22			schema *openapi3.Schema
23			randomValue int64
24			expectedMaxValue int64
25			expectedValue int64
26			}{
27			{
28			"no params, min random value",
29			openapi3.NewSchema(),
30			0,
31			testDefaultMaxInt + 1,
32			0,
33			},
34			{
35			"no params, max random value",
36			openapi3.NewSchema(),
37			testDefaultMaxInt,
38			testDefaultMaxInt + 1,
39			testDefaultMaxInt,
40			},
41			{
42			"given range, min random value",
43			&openapi3.Schema{
44			Min: &min,
45			Max: &max,
46			},
47			0,
48			91,
49			10,
50			},
51			{
52			"given range, max random value",
53			&openapi3.Schema{
54			Min: &min,
55			Max: &max,
56			},
57			90,
58			91,
59			100,
60			},
61			{
62			"given exclusive range, min random value",
63			&openapi3.Schema{
64			Min: &min,
65			Max: &max,
66			ExclusiveMin: true,
67			ExclusiveMax: true,
68			},
69			0,
70			89,
71			11,
72			},
73			{
74			"given exclusive range, max random value",
75			&openapi3.Schema{
76			Min: &min,
77			Max: &max,
78			ExclusiveMin: true,
79			ExclusiveMax: true,
80			},
81			88,
82			89,
83			99,
84			},
85			{
86			"32bit format, min random value",
87			&openapi3.Schema{
88			Format: "int32",
89			},
90			0,
91			testDefaultMaxInt + 1,
92			0,
93			},
94			{
95			"multiple of, random value",
96			&openapi3.Schema{
97			MultipleOf: &min,
98			},
99			17,
100			testDefaultMaxInt + 1,
101			10,
102			},
103			}
104			for _, test := range tests {
105			t.Run(test.name, func(t *testing.T) {
106			randomMock := &mockRandomGenerator{}
107			integerGeneratorInstance := &integerGenerator{
108			random: randomMock,
109			defaultMinimum: testDefaultMinInt,
110			defaultMaximum: testDefaultMaxInt,
111			}
112			randomMock.On("Int63n", test.expectedMaxValue).Return(test.randomValue).Once()
113
114			data, err := integerGeneratorInstance.GenerateDataBySchema(context.Background(), test.schema)
115
116			randomMock.AssertExpectations(t)
117			assert.NoError(t, err)
118			assert.Equal(t, test.expectedValue, data)
119			})
120			}
121			}
122
123			func TestIntegerGenerator_GenerateDataBySchema_MaxLessThanMin_Error(t *testing.T) {
124			integerGeneratorInstance := &integerGenerator{}
125			min := 11.0
126			max := 10.0
127			schema := openapi3.NewSchema()
128			schema.Min = &min
129			schema.Max = &max
130
131			data, err := integerGeneratorInstance.GenerateDataBySchema(context.Background(), schema)
132
133			assert.EqualError(t, err, "[integerGenerator] maximum cannot be less than minimum")
134			assert.Equal(t, 0, data)
135			}
136
137			func TestIntegerGenerator_GenerateDataBySchema_MaxEqualToMin_StaticValue(t *testing.T) {
138			integerGeneratorInstance := &integerGenerator{}
139			min := 10.0
140			max := 10.0
141			schema := openapi3.NewSchema()
142			schema.Min = &min
143			schema.Max = &max
144
145			data, err := integerGeneratorInstance.GenerateDataBySchema(context.Background(), schema)
146
147			assert.NoError(t, err)
148			assert.Equal(t, int64(10), data)
149			}
150

muonsoft / openapi-mock

maAndRandomValue_ExpectedValue B last analyzed 2023-03-11 09:18 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

maAndRandomValue_ExpectedValue B
last analyzed 2023-03-11 09:18 UTC