* Bring the file up to date style-wise with other matcher files
* Bring the tests up to date with other tests
* Improve error messaging
* Simplify documentation
Successive versions of Rails provided explicit support for more column
types such as `money` and `uuid`. However, the ability to create a
Postgres table with one of these column type is really dependent on
which Postgres version you're using, and not which Rails version you're
using -- all you have to do is use `t.column` rather than e.g.,
`t.money`, `t.uuid`, etc.
The main driver behind this commit is to provide a programmatic way to
define models in tests. We already have ways of doing this, of course,
with `define_model` and `define_active_model_class`, but these methods
are very low-level, and in writing tests we have historically made our
own methods inside of test files to define full and complete models. So
we have this common pattern of defining a model with a validation, and
that's repeated across many different files.
What we would like to do, right now, is extract some commonly used
assertions to a shared example group. These assertions need to define
models inside of the tests, but the issue is that sometimes the models
are ActiveRecord models, and sometimes they are ActiveModel models, and
when the shared example group is used within a test file, we need a way
to choose the strategy we'd like to use at runtime. Since the way we
currently define models is via methods, we can't really provide a
strategy very easily. Also, if we need to customize how those models are
defined (say, the attribute needs to be a has-many association instead
of a normal attribute) then the methods only go so far in providing us
that level of customization before things get really complicated.
So, to help us with this, this commit takes the pattern of
model-plus-validation previously mentioned and places it in multiple
classes.
Note that this is also a precursor to a later commit in which we
introduce `ignoring_interference_by_writer` across the board. The way we
will do this is by adding a shared example group that then uses these
model creation classes internally to build objects instead of relying
upon methods that the outer example group -- to which the shared example
group is being mixed into -- provides.
Elliot Winkler