calc-lib/main_test.go at main · JacobMcKenzieSmarty/calc-lib · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package main

import (
	"bytes"
	"errors"
	"reflect"
	"testing"

	"github.com/JacobMcKenzieSmarty/calc-lib/calc"
	"github.com/JacobMcKenzieSmarty/calc-lib/handler"
)

func assertEqual(t *testing.T, expected, actual any) {
	if !reflect.DeepEqual(expected, actual) {
		t.Helper()
		t.Errorf("Expected %v, got %v", expected, actual)
	}
}

func assertError(t *testing.T, expected, actual error) {
	if !errors.Is(expected, actual) {
		t.Helper() //don't pay attention to this as part of the call stack.
		t.Errorf("Expected %v, got %v", expected, actual)
	}
}

func TestTooFewArguments(t *testing.T) {
	myHandler := handler.NewHandler(&bytes.Buffer{}, calc.Addition{})
	err := myHandler.Handle(nil)
	assertError(t, handler.ErrTooFewArgs, err)
}

func TestMalformedFirstArgument(t *testing.T) {
	myHandler := handler.NewHandler(&bytes.Buffer{}, calc.Addition{})
	err := myHandler.Handle([]string{"NaN", "1"})
	assertError(t, handler.ErrMalformedArgs, err)
}

func TestMalformedSecondArgument(t *testing.T) {
	myHandler := handler.NewHandler(&bytes.Buffer{}, calc.Addition{})
	err := myHandler.Handle([]string{"1", "NaN"})
	assertError(t, handler.ErrMalformedArgs, err)
}

func TestOutputWriterError(t *testing.T) {
	taco := errors.New("tacos")
	myHandler := handler.NewHandler(&ErringWriter{taco}, calc.Addition{})
	err := myHandler.Handle([]string{"1", "2"})

	assertError(t, handler.ErrOutputWriter, err)
	assertError(t, taco, err)
}

func TestNilCalculator(t *testing.T) {
	myHandler := handler.NewHandler(&bytes.Buffer{}, nil)
	err := myHandler.Handle([]string{"1", "2"})
	assertError(t, handler.ErrNilCalculator, err)
}

func TestHappyPath(t *testing.T) {
	myBuffer := new(bytes.Buffer)
	myHandler := handler.NewHandler(myBuffer, calc.Addition{})
	err := myHandler.Handle([]string{"1", "2"})
	if err != nil {
		t.Errorf("expected no error, got %v", err)
	}
	result := myBuffer.String()

	assertEqual(t, 2, len(result))
	//if  len(result) != 2 {
	//	t.Errorf("expected myBuffer to be of length 1, got %v", myBuffer.String())
	//}
	assertEqual(t, "3\n", result)
	//if result != "3\n" {
	//	t.Errorf("expected addition result to be 3, got %v", myBuffer.String())
	//}
}

type ErringWriter struct {
	err error
}

func (this *ErringWriter) Write(p []byte) (n int, err error) {
	return 0, this.err
}