domain_test.TestMcq_UpdateAnswer - Code Metrics - Inspection of "Introduce HTMX as a frontend" - memnix/memnix-rest - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#166)

by Yume

created 2024-02-23 13:36 UTC

domain_test.TestMcq_UpdateAnswer B

↳ Parent: domain/mcq_test.go

Complexity

Conditions

Size

Total Lines	55
Code Lines	40

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	40
nop	1
dl	0
loc	55
rs	8.92
c	0
b	0
f	0

How to fix Long Method

package domain_test

import (
	"reflect"
	"testing"

	"github.com/memnix/memnix-rest/domain"
)

func TestMcq_TableName(t *testing.T) {
	mcq := &domain.Mcq{}

	expected := "mcqs"
	tableName := mcq.TableName()

	if tableName != expected {
		t.Errorf("Expected table name to be %s, but got %s", expected, tableName)
	}
}

func TestMcq_IsLinked(t *testing.T) {
	mcq := &domain.Mcq{
		Linked: true,
	}

	expected := true
	isLinked := mcq.IsLinked()

	if isLinked != expected {
		t.Errorf("Expected IsLinked to be %v, but got %v", expected, isLinked)
	}

	mcq2 := &domain.Mcq{
		Linked: false,
	}

	expected2 := false
	isLinked2 := mcq2.IsLinked()

	if isLinked2 != expected2 {
		t.Errorf("Expected IsLinked to be %v, but got %v", expected2, isLinked2)
	}
}

func TestMcq_ExtractAnswers(t *testing.T) {
	testCases := []struct {
		name     string
		answers  string
		expected []string
	}{
		{
			name:     "SingleAnswer",
			answers:  "A",
			expected: []string{"A"},
		},
		{
			name:     "MultipleAnswers",
			answers:  "A;B;C",
			expected: []string{"A", "B", "C"},
		},
		{
			name:     "NoAnswers",
			answers:  "",
			expected: []string{},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			mcq := &domain.Mcq{
				Answers: tc.answers,
			}

			result := mcq.ExtractAnswers()

			if !reflect.DeepEqual(result, tc.expected) {
				t.Errorf("Expected ExtractAnswers to return %v, but got %v", tc.expected, result)
			}
		})
	}
}

func TestMcq_AppendAnswer(t *testing.T) {
	mcq := &domain.Mcq{
		Answers: "A",
	}

	answer := "B"
	expected := "A;B"
	mcq.AppendAnswer(answer)

	if mcq.Answers != expected {
		t.Errorf("Expected Answers to be %s, but got %s", expected, mcq.Answers)
	}
}

func TestMcq_RemoveAnswer(t *testing.T) {
	testCases := []struct {
		name     string
		answers  string
		answer   string
		expected string
	}{
		{
			name:     "SingleAnswer",
			answers:  "A",
			answer:   "A",
			expected: "",
		},
		{
			name:     "MultipleAnswers",
			answers:  "A;B;C",
			answer:   "B",
			expected: "A;C",
		},
		{
			name:     "NoAnswers",
			answers:  "",
			answer:   "A",
			expected: "",
		},
		{
			name:     "AnswerNotInAnswers",
			answers:  "A;B;C",
			answer:   "D",
			expected: "A;B;C",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			mcq := &domain.Mcq{
				Answers: tc.answers,
			}

			mcq.RemoveAnswer(tc.answer)

			if mcq.Answers != tc.expected {
				t.Errorf("Expected Answers to be %s, but got %s", tc.expected, mcq.Answers)
			}
		})
	}
}

func TestMcq_UpdateAnswer(t *testing.T) {
	testCases := []struct {
		name      string
		answers   string
		oldAnswer string
		newAnswer string
		expected  string
	}{
		{
			name:      "SingleAnswer",
			answers:   "A",
			oldAnswer: "A",
			newAnswer: "B",
			expected:  "B",
		},
		{
			name:      "MultipleAnswers",
			answers:   "A;B;C",
			oldAnswer: "B",
			newAnswer: "D",
			expected:  "A;D;C",
		},
		{
			name:      "NoAnswers",
			answers:   "",
			oldAnswer: "A",
			newAnswer: "B",
			expected:  "",
		},
		{
			name:      "AnswerNotInAnswers",
			answers:   "A;B;C",
			oldAnswer: "D",
			newAnswer: "E",
			expected:  "A;B;C",
		},
		{
			name:      "AnswerNotInAnswers",
			answers:   "A;B;C",
			oldAnswer: "B",
			newAnswer: "A",
			expected:  "A;A;C",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			mcq := &domain.Mcq{
				Answers: tc.answers,
			}

			mcq.UpdateAnswer(tc.oldAnswer, tc.newAnswer)

			if mcq.Answers != tc.expected {
				t.Errorf("Expected Answers to be %s, but got %s", tc.expected, mcq.Answers)
			}
		})
	}
}


1			package domain_test
2
3			import (
4			"reflect"
5			"testing"
6
7			"github.com/memnix/memnix-rest/domain"
8			)
9
10			func TestMcq_TableName(t *testing.T) {
11			mcq := &domain.Mcq{}
12
13			expected := "mcqs"
14			tableName := mcq.TableName()
15
16			if tableName != expected {
17			t.Errorf("Expected table name to be %s, but got %s", expected, tableName)
18			}
19			}
20
21			func TestMcq_IsLinked(t *testing.T) {
22			mcq := &domain.Mcq{
23			Linked: true,
24			}
25
26			expected := true
27			isLinked := mcq.IsLinked()
28
29			if isLinked != expected {
30			t.Errorf("Expected IsLinked to be %v, but got %v", expected, isLinked)
31			}
32
33			mcq2 := &domain.Mcq{
34			Linked: false,
35			}
36
37			expected2 := false
38			isLinked2 := mcq2.IsLinked()
39
40			if isLinked2 != expected2 {
41			t.Errorf("Expected IsLinked to be %v, but got %v", expected2, isLinked2)
42			}
43			}
44
45			func TestMcq_ExtractAnswers(t *testing.T) {
46			testCases := []struct {
47			name string
48			answers string
49			expected []string
50			}{
51			{
52			name: "SingleAnswer",
53			answers: "A",
54			expected: []string{"A"},
55			},
56			{
57			name: "MultipleAnswers",
58			answers: "A;B;C",
59			expected: []string{"A", "B", "C"},
60			},
61			{
62			name: "NoAnswers",
63			answers: "",
64			expected: []string{},
65			},
66			}
67
68			for _, tc := range testCases {
69			t.Run(tc.name, func(t *testing.T) {
70			mcq := &domain.Mcq{
71			Answers: tc.answers,
72			}
73
74			result := mcq.ExtractAnswers()
75
76			if !reflect.DeepEqual(result, tc.expected) {
77			t.Errorf("Expected ExtractAnswers to return %v, but got %v", tc.expected, result)
78			}
79			})
80			}
81			}
82
83			func TestMcq_AppendAnswer(t *testing.T) {
84			mcq := &domain.Mcq{
85			Answers: "A",
86			}
87
88			answer := "B"
89			expected := "A;B"
90			mcq.AppendAnswer(answer)
91
92			if mcq.Answers != expected {
93			t.Errorf("Expected Answers to be %s, but got %s", expected, mcq.Answers)
94			}
95			}
96
97			func TestMcq_RemoveAnswer(t *testing.T) {
98			testCases := []struct {
99			name string
100			answers string
101			answer string
102			expected string
103			}{
104			{
105			name: "SingleAnswer",
106			answers: "A",
107			answer: "A",
108			expected: "",
109			},
110			{
111			name: "MultipleAnswers",
112			answers: "A;B;C",
113			answer: "B",
114			expected: "A;C",
115			},
116			{
117			name: "NoAnswers",
118			answers: "",
119			answer: "A",
120			expected: "",
121			},
122			{
123			name: "AnswerNotInAnswers",
124			answers: "A;B;C",
125			answer: "D",
126			expected: "A;B;C",
127			},
128			}
129
130			for _, tc := range testCases {
131			t.Run(tc.name, func(t *testing.T) {
132			mcq := &domain.Mcq{
133			Answers: tc.answers,
134			}
135
136			mcq.RemoveAnswer(tc.answer)
137
138			if mcq.Answers != tc.expected {
139			t.Errorf("Expected Answers to be %s, but got %s", tc.expected, mcq.Answers)
140			}
141			})
142			}
143			}
144
145			func TestMcq_UpdateAnswer(t *testing.T) {
146			testCases := []struct {
147			name string
148			answers string
149			oldAnswer string
150			newAnswer string
151			expected string
152			}{
153			{
154			name: "SingleAnswer",
155			answers: "A",
156			oldAnswer: "A",
157			newAnswer: "B",
158			expected: "B",
159			},
160			{
161			name: "MultipleAnswers",
162			answers: "A;B;C",
163			oldAnswer: "B",
164			newAnswer: "D",
165			expected: "A;D;C",
166			},
167			{
168			name: "NoAnswers",
169			answers: "",
170			oldAnswer: "A",
171			newAnswer: "B",
172			expected: "",
173			},
174			{
175			name: "AnswerNotInAnswers",
176			answers: "A;B;C",
177			oldAnswer: "D",
178			newAnswer: "E",
179			expected: "A;B;C",
180			},
181			{
182			name: "AnswerNotInAnswers",
183			answers: "A;B;C",
184			oldAnswer: "B",
185			newAnswer: "A",
186			expected: "A;A;C",
187			},
188			}
189
190			for _, tc := range testCases {
191			t.Run(tc.name, func(t *testing.T) {
192			mcq := &domain.Mcq{
193			Answers: tc.answers,
194			}
195
196			mcq.UpdateAnswer(tc.oldAnswer, tc.newAnswer)
197
198			if mcq.Answers != tc.expected {
199			t.Errorf("Expected Answers to be %s, but got %s", tc.expected, mcq.Answers)
200			}
201			})
202			}
203			}
204

memnix / memnix-rest

Pull Request — main (#166)

domain_test.TestMcq_UpdateAnswer B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like