assert: introducing no field is empty assertion function

[PeterEFinch]

Summary

Proposal to introduce an assertion that checks that no (exported) fields are empty in a struct.

Changes

1. A function NoFieldIsEmpty is introduced into into the assert package. This function fails the test and returns false if any of the fields in the inputed struct (or reference to struct) are empty, aligning with pre-existing definition of empty.
2. Tests for the newly introduced NoFieldIsEmpty function were added.
3. go generate ./... was run.

Motivation

I found myself repeatedly rewriting similar code in tests across different repositories in an effort to ensure that tests do not become out-of-date and no longer align with their original intention.

An example of this is writing tests that check that all fields in a struct can be stored and then loaded. Consider the test:

// Tests that all fields in entity can be stored and loaded
func TestPersistence(t *testing.T) {
	entity := Entity{
		// Filled with data
	}
	
	s := NewStore()
	err := s.Store(entity)
	require.NoError(t, err)
	
	result, err := s.Load(entity.ID)
	require.NoError(t, err)
	assert.Equal(t, entity, result, "result should match the entity stored")
}

This test is claiming to check that all fields can be stored and loaded but it not enforcing it. If the entity was not correctly populated initially or if new fields where added to the Entity and the test was not updated then the test would not be align with its stated purpose.

In this particular case the assertion could be used as a pre-condition to ensure we always start with all fields containing data

require.NoFieldIsEmpty(t, entity)

or as check at the end of test to ensure all fields where populated

assert.NoFieldIsEmpty(t, result)

I have found this assertion useful for when using tests that require populated structs including:

1. Testing the storing and loading of structs into database or persistence storage.
2. Testing the population of structs e.g. writing fakers.
3. Testing the marshalling/formatting of structs and unmarshalling/parsing data to structs.

Related issues

None.

Additional comments

1. This form of assertion does not appear to be wide spread from what I have seen and thus maybe is of low impact - however, maybe that is just due to a dislike of reflection 😅.
2. Although I find such an assertion useful there are times when I want all bar some fields populated and it might be better to have a function with the signature

func NoFieldIsEmpty(t TestingT, object interface{}, exclude []string, msgAndArgs ...interface{}) bool

3. This assertion doesn't solve the issue of nested structs are populated too (although it does help). I avoided approaching addressing this because it was unclear of how to express nested field names and handle arrays of structs. Also, having some feedback on the the simple case seemed to be a good starting point.
4. Thank you for reading & reviewing 😄

[PeterEFinch]

Please let me know if I should also create an issue alongside this PR as it is for proposed functionality.

EDIT: I created an issue for this as well #1601.

[brackendawson]

What does "empty" mean? It's not in the language spec. From reading the code it seems to be "zero values for most types or with length of zero for some of the container types".

This assertion's behaviour needs to be clearly documented. I can't review it as it is because I can't tell what empty is supposed to mean. I think it's supposed to mean unpopulated struct fields? If that is the case then it doesn't work, see discussion in #1601.

[PeterEFinch]

I am happy to have more explicit documentation.

One option would be to provide a godoc link to the current assert.Empty function e.g.

NoFieldIsEmpty asserts that object, which must be a struct or eventually reference to one, has no exported field with a value that is empty (following the definition of empty used in [Empty]).

Another option is to include the same definition used in assert.Empty in the documentation for this function e.g.

NoFieldIsEmpty asserts that object, which must be a struct or eventually reference to one, has no exported field with a value that is empty I.e. nil, "", false, 0 or either a slice or a channel with len == 0.

Do find either these clear enough?

P.S. I am aware that "empty" is not part of the go spec. My intent was to follow a definition already used by this library (that I have found useful) rather than invent something myself.

[brackendawson]

The godoc link would be sufficient.