How can I simulate a failure of rand.Reader for testing purposes?

I am trying to write a unit test for my function; note that it calls rand.Read (from the crypto/rand package), which relies on rand.Reader:

func GenerateBytes(length int) ([]byte, error) {
	bytes := make([]byte, length)
	if _, err := rand.Read(bytes); err != nil {
		return nil, err
	}
	return bytes, nil
}

I am able to write tests for the happy path, but I'm unable to test the case where rand.Read returns an error... Is there a way to simulate a failure of rand.Read?

What exactly are you trying to check? That, if rand.Read returns a non-nil error, then so does GenerateBytes? Are you simply trying to get the coverage percentage above some arbitrary threshold, or is such a check actually important to you? In the former case, please reconsider.

In the latter case, be aware that depending directly on package-level singletons like rand.Reader makes testing difficult. Improving testability requires some additional (but not prohibitive) effort.

One possible approach

Thankfully, there's already a convenient interface that rand.Reader satisfies: io.Reader. If no such interface were already available, though, no biggie; you could have declared your own custom one. That's what's great about Go interfaces' implicit satisfaction!

Choose a way to pass an io.Reader to GenerateBytes. The most idiomatic way is to declare GenerateBytes, not as a top-level function, but as a method on some custom struct type (named SourceOfRandomness below) that has a (possibly anonymous) io.Reader field:

type SourceOfRandomness struct {
	Reader io.Reader
}

Doing so allows you to choose which io.Reader implementor to inject at instantiation of your custom type. GenerateBytes can then access the io.Reader it needs through its receiver:

func (sor *SourceOfRandomness) GenerateBytes(length int) ([]byte, error) {
	bytes := make([]byte, length)
	if _, err := sor.Reader.Read(bytes); err != nil {
		return nil, err
	}
	return bytes, nil
}

Then, in your production code, you'd initialise a SourceOfRandomness value with the actual rand.Reader:

sor := SourceOfRandomness{Reader: rand.Reader}
sor.GenerateBytes(42)

For the specific test case you had in mind, you can simply leverage (as mentioned by mh-cbon in his comment) iotest.ErrReader, which returns an io.Reader whose Read method unconditionally fails:

import (
  "crypto/rand"
  "testing/iotest"
)

func TestGenerateBytesFails(t *testing.T) {
  // Arrange
  sor := SourceOfRandomness{
    Reader: iotest.ErrReader(errors.New("oops"))
  }
  const dummyLength = 42
  // Act
  _, err := sor.GenerateBytes(dummyLength)
  // Assert
  if err != nil {
    t.Error("want non-nil error; got nil error")
  }
}