テスト駆動開発実践：ゆめみさんの模試を題材にして

package ranking

func TestReadCsv(t *testing.T) {
	path := "../testdata/input.csv"
	parsed, err := filepath.Abs(path)
	if err != nil {
		t.Error("could not parse filepath")
	}
	f, err := os.Open(parsed)
	if err != nil {
		t.Error("could not open file")
	}
	defer f.Close()
	reader := csv.NewReader(f)

	for {
		record, err := reader.Read()
		if err == io.EOF {
			return
		}
		if err != nil {
			t.Error("could not read csv line")
		}
		fmt.Println(record)
	}
}

=== RUN   TestReadCsv
[create_timestamp player_id score]
[2021/01/01 12:00 player0001 12345]
[2021/01/02 13:00 player0002 10000]
[2021/01/03 12:00 player0021 100]
[2021/01/04 12:10 player0031 300]
[2021/01/05 12:00 player0041 300]
[2021/01/06 12:00 player0001 10000]
--- PASS: TestReadCsv (0.00s)

ranking/
    |- ranking.go
    |- ranking_test.go
main.go
go.mod
go.sum

func TestValidateHeader(t *testing.T) {
	validHeader := []string{"create_timestamp", "player_id", "score"}
	if !ValidateHeader(validHeader) {
		t.Error("validation fails")
	}

	invalidHeader := []string{"create_timestamp ", "player_id ", "score "}
	if ValidateHeader(invalidHeader) {
		t.Error("validation fails")
	}

	invalidHeader = []string{"create_timestamp", "player_id"}
	if ValidateHeader(invalidHeader) {
		t.Error("validation fails")
	}
}

+type PlayerMean struct {
+	player string
+	mean   float32
+}

type Ranking struct {
	sumBoard  map[string]SumCounter
+	meanBoard []*PlayerMean
}

func NewRanking() *Ranking {
+	cap_player := 1000
	rank := new(Ranking)
	rank.sumBoard = make(map[string]SumCounter)
+	rank.meanBoard = make([]*PlayerMean, 0, cap_player)
	return rank
}

func (r *Ranking) Aggregate(records *csv.Reader) {
	if records == nil {
		return
	}

	header, err := records.Read()
	if err != nil {
		return
	}
	if !ValidateHeader(header) {
		return
	}

	for {
		record, err := records.Read()
		if err == io.EOF {
			break
		}
		// ある行が無効だったら飛ばして処理を継続する
		if err != nil {
			continue
		}
		r.updateSum(record)
	}
+	r.updateMean()
}

+func (r *Ranking) updateMean() {
+	for player, sumCounter := range r.sumBoard {
+		cnt := sumCounter.count
+		if cnt == 0 {
+			continue
+		}
+		mean := float32(sumCounter.sum) / float32(cnt)
+		r.meanBoard = append(r.meanBoard, &PlayerMean{player, mean})
+	}
+}

func sortMeanBoard(board []*PlayerMean) {
	// 平均点で並び替え
	sort.Slice(board, func(i, j int) bool {
		return board[i].mean > board[j].mean
	})
}

func TestValidateHeader(t *testing.T) {
	validHeader := []string{"create_timestamp", "player_id", "score"}
	if !ValidateHeader(validHeader) {
		t.Error("validation fails")
	}

	invalidHeader := []string{"create_timestamp ", "player_id ", "score "}
	if ValidateHeader(invalidHeader) {
		t.Error("validation fails")
	}

	invalidHeader = []string{"create_timestamp", "player_id"}
	if ValidateHeader(invalidHeader) {
		t.Error("validation fails")
	}
}

func TestParseRecord(t *testing.T) {
	r := []string{"2021/01/01 12:00", "player0001", "12345"}
	parsed, err := ParseRecord(r)
	if err != nil {
		t.Error("could not parse a valid input")
	}
	if parsed.player != r[1] {
		t.Error("player: not expected value")
	}
	if parsed.score != 12345 {
		t.Error("score: not expected value")
	}
	// scoreは型変換が入るのでチェックする
	if fmt.Sprintf("%T", parsed.score) != "int" {
		t.Error("score type: not expected type")
	}
}

func TestAggregate(t *testing.T) {
	path, _ := filepath.Abs("../testdata/input.csv")
	f, err := os.Open(path)
	if err != nil {
		t.Error("bad test: could not load test input")
	}
	defer f.Close()

	data := csv.NewReader(f)
	recorder := NewRecorder()
	recorder.Aggregate(data)

	sumBoard := recorder.sumBoard
	tests := map[string]int{
		"player0001": 22345,
		"player0002": 10000,
	}
	for player, sum := range tests {
		if sumCounter := sumBoard[player]; sumCounter.sum != sum {
			t.Errorf("expected %d: got %d\n", sum, sumCounter.sum)
		}
	}

	meanBoard := recorder.meanBoard
	meanTests := []PlayerMean{
		{"player0001", 22345.0 / 2},
		{"player0002", 10000},
	}
	hits := 0
	for _, expected := range meanTests {
		for _, calculated := range meanBoard {
			if expected.player == calculated.player {
				hits++
				if expected.mean != calculated.mean {
					t.Errorf("expected %f, got %f\n", expected.mean, calculated.mean)
				}
			}
		}
	}
	if hits != len(meanTests) {
		t.Errorf("player num is insufficient")
	}
}

func TestSortMeanBoard(t *testing.T) {
	test := []*PlayerMean{
		{"player2", 100},
		{"player1", 100},
		{"player3", 200},
		{"player4", 50},
	}
	// 要求にないので同点の時にプレイヤー名の五十音で並び替えるなどは実装していない
	expected := []*PlayerMean{
		{"player3", 200},
		{"player2", 100},
		{"player1", 100},
		{"player4", 50},
	}
	// this method override order
	sortMeanBoard(test)
	for i, player := range expected {
		if test[i].player != player.player {
			t.Errorf("unexpected order at index of %d", i)
		}
	}
}

package ranking

import (
	"errors"
	"sort"
	"strconv"
)

type ParsedRecord struct {
	player string
	score  int
}

func ValidateHeader(header []string) bool {
	expected := []string{"create_timestamp", "player_id", "score"}
	if len(header) != 3 {
		return false
	}
	for i, h := range expected {
		if header[i] != h {
			return false
		}
	}
	return true
}

// input: []string{date, player, score}
func ParseRecord(r []string) (*ParsedRecord, error) {
	if len(r) != 3 {
		return nil, errors.New("invalid input")
	}
	score, err := strconv.Atoi(r[2])
	if err != nil {
		return nil, err
	}
	// scoreの最大値超え確認は必要？
	return &ParsedRecord{r[1], score}, nil
}

func sortMeanBoard(board []*PlayerMean) {
	// 平均点で並び替え
	sort.Slice(board, func(i, j int) bool {
		return board[i].mean > board[j].mean
	})
}

package ranking

import (
	"encoding/csv"
	"io"
)

type SumCounter struct {
	sum   int
	count int
}

type PlayerMean struct {
	player string
	mean   float32
}

type Recorder struct {
	sumBoard  map[string]SumCounter
	meanBoard []*PlayerMean
}

func NewRecorder() *Recorder {
	cap_player := 1000
	recorder := new(Recorder)
	recorder.sumBoard = make(map[string]SumCounter)
	recorder.meanBoard = make([]*PlayerMean, 0, cap_player)
	return recorder
}

func (r *Recorder) Aggregate(records *csv.Reader) {
	if records == nil {
		return
	}

	header, err := records.Read()
	if err != nil {
		return
	}
	if !ValidateHeader(header) {
		return
	}

	for {
		record, err := records.Read()
		if err == io.EOF {
			break
		}
		// ある行が無効だったら飛ばして処理を継続する
		if err != nil {
			continue
		}
		r.updateSum(record)
	}
	r.updateMean()
}

func (r *Recorder) updateSum(record []string) {
	parsed, err := ParseRecord(record)
	if err != nil {
		return
	}
	current, exist := r.sumBoard[parsed.player]
	if !exist {
		r.sumBoard[parsed.player] = SumCounter{parsed.score, 1}
	} else {
		r.sumBoard[parsed.player] = SumCounter{
			current.sum + parsed.score,
			current.count + 1,
		}
	}
}

func (r *Recorder) updateMean() {
	for player, sumCounter := range r.sumBoard {
		cnt := sumCounter.count
		if cnt == 0 {
			continue
		}
		mean := float32(sumCounter.sum) / float32(cnt)
		r.meanBoard = append(r.meanBoard, &PlayerMean{player, mean})
	}
}

func TestJudgeOutput(t *testing.T) {
	path, _ := filepath.Abs("../testdata/input.csv")
	f, err := os.Open(path)
	if err != nil {
		t.Error("bad test: could not load test input")
	}
	defer f.Close()

	data := csv.NewReader(f)
	recorder := NewRecorder()
	recorder.Aggregate(data)

	judge := NewJudge(recorder)
	writer := new(bytes.Buffer)

	judge.SetWriter(writer)
	judge.Output()
	expectedSlice := []string{
		"1,player0001,11172.50",
		"2,player0002,10000.00",
		"3,player0031,300.00",
		"3,player0041,300.00",
		"5,player0021,100.00",
	}

	s := writer.String()
	s = strings.TrimRight(s, "\n") // trim last newline
	ss := strings.Split(s, "\n")

	for _, expected := range expectedSlice {
		if !isin(expected, ss) {
			t.Errorf("could not find %s\n", expected)
		}
	}
}

func isin(target string, words []string) bool {
	for _, w := range words {
		if target == w {
			return true
		}
	}
	return false
}

package ranking

import (
	"fmt"
	"io"
	"os"
)

const DISPLAY_MAX_RANK = 10

type Judge struct {
	last   float32
	rank   int
	skip   int
	record *Recorder
	writer io.Writer
}

func NewJudge(r *Recorder) *Judge {
	judge := new(Judge)
	judge.last = 0.0
	judge.rank = 0
	judge.skip = 0
	judge.record = r
	return judge
}

func (j *Judge) SetWriter(w io.Writer) {
	j.writer = w
}

func (j *Judge) Output() {
	w := j.writer
	if j.writer == nil {
		w = os.Stdout
	}
	for _, playerMean := range j.record.meanBoard {

		// 同点を考慮して例えば 1, 1, 3　のような順位を表示するための処理
		if j.last != playerMean.mean {
			j.last = playerMean.mean
			j.rank = j.rank + j.skip + 1
			j.skip = 0
		} else {
			j.skip++
		}

		if j.rank > DISPLAY_MAX_RANK {
			break
		}
		fmt.Fprintf(w, "%d,%s,%.2f\n", j.rank, playerMean.player, playerMean.mean)
	}
}

func TestIntegration(t *testing.T) {
	es := []string{
		"1,player0001,11563.33",
		"2,player0002,10000.00",
		"3,player001,1000.00",
		"3,player002,1000.00",
		"5,player0031,300.00",
		"5,player0041,300.00",
		"7,player0021,100.00",
		"7,player01,100.00",
		"7,player02,100.00",
		"10,player031,30.00",
		"10,player041,30.00",
	}

	filename := "../testdata/large.csv"
	writer := new(bytes.Buffer)
	err := GetRank(filename, writer)
	if err != nil {
		t.Errorf("Got error: %s\n", err.Error())
	}

	// note: return values' order could not be guaranteed
	s := writer.String()
	s = strings.TrimRight(s, "\n") // trim last newline
	ss := strings.Split(s, "\n")

	for _, expected := range es {
		if !isin(expected, ss) {
			t.Errorf("could not find %s\n", expected)
		}
	}
}

func GetRank(filename string, w io.Writer) error {
	path, err := filepath.Abs(filename)
	if err != nil {
		return err
	}
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()

	data := csv.NewReader(f)
	recorder := NewRecorder()
	recorder.Aggregate(data)

	judge := NewJudge(recorder)
	judge.SetWriter(w)
	judge.Output()
	return nil
}