probo/store/memory/memory_test.go

package memory

import (
	"fmt"
	"reflect"
	"testing"

	"git.andreafazzi.eu/andrea/probo/client"
	"git.andreafazzi.eu/andrea/probo/hasher/sha256"
	"github.com/remogatto/prettytest"
)

type testSuite struct {
	prettytest.Suite
}

func TestRunner(t *testing.T) {
	prettytest.Run(
		t,
		new(testSuite),
	)
}

func (t *testSuite) TestReadQuizByHash() {
	store := NewMemoryProboCollectorStore(
		sha256.NewDefault256Hasher(sha256.DefaultSHA256HashingFn),
	)
	quiz, _ := store.CreateQuiz(
		&client.CreateUpdateQuizRequest{
			Quiz: &client.Quiz{
				Question: &client.Question{Text: "Newly created question text."},
				Answers: []*client.Answer{
					{Text: "Answer 1", Correct: true},
					{Text: "Answer 2", Correct: false},
					{Text: "Answer 3", Correct: false},
					{Text: "Answer 4", Correct: false},
				},
			},
		})
	quizFromMemory, err := store.ReadQuizByHash(quiz.Hash)
	t.Nil(err, "Quiz should be found in the store")
	if !t.Failed() {
		t.True(reflect.DeepEqual(quizFromMemory, quiz), "Quiz should be equal")
	}

}

func (t *testSuite) TestParseTextForTags() {
	store := NewMemoryProboCollectorStore(
		sha256.NewDefault256Hasher(sha256.DefaultSHA256HashingFn),
	)
	quiz, _ := store.CreateQuiz(
		&client.CreateUpdateQuizRequest{
			Quiz: &client.Quiz{
				Question: &client.Question{Text: "Newly created question text with #tag1."},
				Answers: []*client.Answer{
					{Text: "Answer 1", Correct: true},
					{Text: "Answer 2 with #tag2", Correct: false},
					{Text: "Answer 3", Correct: false},
					{Text: "Answer 4", Correct: false},
				},
			},
		})
	quizFromMemory, err := store.ReadQuizByHash(quiz.Hash)
	t.Nil(err, "Quiz should be found in the store")
	if !t.Failed() {
		t.True(len(quizFromMemory.Tags) == 2, "Two tags should be present.")
		t.Equal("#tag1", quizFromMemory.Tags[0].Name)
		t.Equal("#tag2", quizFromMemory.Tags[1].Name)
	}

}

func (t *testSuite) TestUpdateQuiz() {
	store := NewMemoryProboCollectorStore(
		sha256.NewDefault256Hasher(sha256.DefaultSHA256HashingFn),
	)
	quiz, _ := store.CreateQuiz(
		&client.CreateUpdateQuizRequest{
			Quiz: &client.Quiz{
				Question: &client.Question{Text: "Newly created question text."},
				Answers: []*client.Answer{
					{Text: "Answer 1", Correct: true},
					{Text: "Answer 2", Correct: false},
					{Text: "Answer 3", Correct: false},
					{Text: "Answer 4", Correct: false},
				},
			},
		})

	createdQuizHash := quiz.Hash

	updatedQuiz, updated, err := store.UpdateQuiz(
		&client.CreateUpdateQuizRequest{
			Quiz: &client.Quiz{
				Question: &client.Question{Text: "Updated question text."},
				Answers: []*client.Answer{
					{Text: "Answer 1", Correct: true},
					{Text: "Updated Answer 2", Correct: false},
					{Text: "Answer 3", Correct: false},
					{Text: "Answer 4", Correct: false},
				},
			},
		}, quiz.ID)

	t.Nil(err, fmt.Sprintf("The update returned an error: %v", err))

	if !t.Failed() {
		t.True(updated)
		t.True(createdQuizHash != updatedQuiz.Hash, "The two hashes should not be equal.")
		t.Equal(4, len(updatedQuiz.Answers))
		t.Equal("Updated question text.", updatedQuiz.Question.Text)
		t.Equal("Updated Answer 2", updatedQuiz.Answers[1].Text)
	}
}

func (t *testSuite) TestDeleteQuiz() {
	store := NewMemoryProboCollectorStore(
		sha256.NewDefault256Hasher(sha256.DefaultSHA256HashingFn),
	)
	quiz, _ := store.CreateQuiz(
		&client.CreateUpdateQuizRequest{
			Quiz: &client.Quiz{
				Question: &client.Question{Text: "This test should be removed."},
				Answers: []*client.Answer{
					{Text: "Answer 1", Correct: true},
					{Text: "Answer 2", Correct: false},
					{Text: "Answer 3", Correct: false},
					{Text: "Answer 4", Correct: false},
				},
			},
		})

	deletedQuiz, err := store.DeleteQuiz(quiz.ID)

	t.Equal(quiz.ID, deletedQuiz.ID, "Returned deleted quiz ID should be equal to the request")
	t.Nil(err, fmt.Sprintf("The update returned an error: %v", err))

	_, err = store.ReadQuizByHash(quiz.Hash)
	t.True(err != nil, "Reading a non existent quiz should return an error")
}

func (t *testSuite) TestUpdateCollection() {
	store := NewMemoryProboCollectorStore(
		sha256.NewDefault256Hasher(sha256.DefaultSHA256HashingFn),
	)

	quiz_1, _ := store.CreateQuiz(
		&client.CreateUpdateQuizRequest{
			Quiz: &client.Quiz{
				Question: &client.Question{Text: "Question text with #tag1."},
				Answers: []*client.Answer{
					{Text: "Answer 1", Correct: true},
					{Text: "Answer 2", Correct: false},
					{Text: "Answer 3", Correct: false},
					{Text: "Answer 4", Correct: false},
				},
			},
		})

	quiz_2, _ := store.CreateQuiz(
		&client.CreateUpdateQuizRequest{
			Quiz: &client.Quiz{
				Question: &client.Question{Text: "Another question text with #tag1."},
				Answers: []*client.Answer{
					{Text: "Answer 1", Correct: true},
					{Text: "Answer 2", Correct: false},
					{Text: "Answer 3", Correct: false},
					{Text: "Answer 4", Correct: false},
				},
			},
		})

	collection, _ := store.CreateCollection(
		&client.CreateUpdateCollectionRequest{
			Collection: &client.Collection{
				Name: "MyCollection",
			},
		})

	updatedCollection, updated, err := store.UpdateCollection(
		&client.CreateUpdateCollectionRequest{
			Collection: &client.Collection{
				Name:  "MyUpdatedCollection",
				Query: "#tag1",
			},
		}, collection.ID)

	t.Nil(err, fmt.Sprintf("The update returned an error: %v", err))

	if !t.Failed() {
		t.True(updated)
		t.Equal("MyUpdatedCollection", updatedCollection.Name)
		t.True(len(updatedCollection.IDs) == 2)
		if !t.Failed() {
			t.Equal(quiz_1.ID, updatedCollection.IDs[0])
			t.Equal(quiz_2.ID, updatedCollection.IDs[1])
		}
	}
}