How to create unit test for in-memory datastore?

I wanted to create some simple REST API. I decided to create my own in-memory datastore which implements such interface:

type datastore interface {
	Add(*Element) error
	Get(ElementID) (*Element, error)
	Update(*Element) error
	Delete(ElementID) error
	GetAll() []*Element
}

type Datastore struct {
	mu     sync.Mutex
	bucket map[string]*Element
}

func NewDB() *Datastore {
	return &Datastore {
		bucket: make(map[string]*Element),
	}
}

How should this be unit tested?

Some of the tests I managed to create looks like this:

func TestGetAllTODOTasks(t *testing.T) {
	ts := NewDB()
	var elem = &Element{fieldA : "A" , fieldB : "B"}
	ts.Create(elem)

	want := []*Element{elem}

	if got := ts.GetAll(); !reflect.DeepEqual(got, want) {
		t.Errorf("Got %v wanted %v", got, want)
	}
}

But once I wanted to test other methods like Update, I realized that I need to use Create first and then update like this:

func TestUpdateTODOTasks(t *testing.T) {
	ts := NewDB()
	var elem = &Element{fieldA : "A" , fieldB : "B"}
	ts.Create(elem)
	if err != nil {
		t.Errorf("=> failed to create: %v", err.Error())
	}
	var updated_elem = &Element{fieldA : "A-updated" , fieldB : "B"}

	err = ts.Update(updated_elem )

	if err != nil {
		t.Errorf("=> failed to update: %v", err.Error())
	}

}

You can initialize your underlying map relying on the implementation detail that your storage indeed uses the map under the hood.

In general, you can really benefit from the tests you described. So seed the tested storage by using the defined API. It brings your tests closer to the way a client uses your code. There is no need to artificially modify the underlying state. I’ve seen a lot of tests doing so and they usually become hard to maintain and flaky.

Don’t be so attach to the fact than unit tests have to check exactly one function. In fact, they’re more about testing integral, independent, small parts of the software so it doesn’t have to be a single function at all.