Expectate: A Go Testing Utility
Tags: testing, go
Published: 2020-12-22 07:34:29

Do you love the simplicity of Go testing but hate writing if statements constantly?

Do you like the 'expect' style syntax of testing libraries like **jest** in JavaScript but don't care for Gomega?

The answer:
### Expectate 
[github.com/gomagedon/expectate](https://github.com/gomagedon/expectate)

## Why is Expectate better than Gomega?
---
Well, that's a matter of opinion. The main differences are:

- Expectate is simpler
- The syntax is a little different (closer to jest)

## How is it simpler?
---
If you've ever used Gomega (the Ginkgo assertion tool)...

You wouldn't describe it as simple. It does a lot. Like a lot a lot. There are a lot of ways to write the same thing. For example:

```golang
err := DoSomethingSimple()
Ω(err).ShouldNot(HaveOccurred())
```
Is the same as:
```golang
Ω(DoSomethingSimple()).Should(Succeed())
```
And that's not to mention the Expect syntax:
```golang
g.Expect(DoSomethingSimple()).To(Succeed())
```
And those are just the different ways to assert that an error is nil!

### The Expectate Way:
```golang
err := DoSomethingSimple()
expect(err).NotToBe(nil)
```
That's it.
No alternative syntax.

In fact, Expectate has only 4 methods!
- `ToBe()`
- `ToEqual()`
- `NotToBe()`
- `NotToEqual()`

`ToBe()` checks for simple equality, i.e. `var1 == var2`

`ToEqual()` checks for deep equality using [google/go-cmp](github.com/google/go-cmp)

`NotToBe()` and `NotToEqual()` check for the opposite cases just like you would expect! (pun intended)

## That's all it does?
---
Yeah. So what?

It's all syntactic sugar. The whole point is to turn a three-line *if* statement into one line that looks nice and pretty. Gomega doesn't *actually* provide much more functionality, just more ways to write the same thing.

Expectate is real nice and lightweight :sunglasses:

If I download the latest version of Gomega from GitHub, guess how big the zip file is?

### Gomega size:

> gomega-1.10.4.zip: **163K**

### Compared to Expectate:

> expectate-1.0.0.zip: **7K**

---
Not to mention that all the production code for Expectate is in a single file, and 80% of that 7K is probably the tests.

## So this is just another stupid testing library that doesn't do much?
---
Right again.

### Don't use it for everything!

If you want a more descriptive error message than `foo is not bar`, just use `testing.T` like normal!!

## A Note On Compatibility
---
Expectate doesn't *have* to use testing.T (although you really should)!

Typically you would write an Expectate test like this:

```golang
func TestFooIsBar(t *testing.T) {
  expect := expectate.Expect(t)
  expect("foo").ToBe("bar")
}
```
And the output:
```
--- FAIL: TestFooIsBar (0.00s)
    expect.go:34: foo is not bar
```
---
The above example uses testing.T (as our lord and savior Rob Pike intended)
But you can use any object that satisfies the `Fataler` interface!
```golang
type Fataler interface {
  Fatal(args ...interface{})
}
```

So anyway check it out! It's my very new project, so please give lots of feedback, positive or negative! Open all the issues!

[github.com/gomagedon/expectate](https://github.com/gomagedon/expectate)