Unexpected non-iterable value for to-many relation - unit-testing

Question

When I run the phpunit,
$this->assertResponseIsSuccessful();
show the error:
'hydra:description' => 'Unexpected non-iterable value for to-many relation'
Failed asserting that the Response is successful.
HTTP/1.1 400 Bad Request
Cache-Control: no-cache, private
Content-Type: application/ld+json; charset=utf-8
Date: Fri, 09 Jul 2021 13:06:48 GMT
Link: <http://example.com/docs.jsonld>; rel="http://www.w3.org/ns/hydra/core#apiDocumentation"
X-Content-Type-Options: nosniff
X-Frame-Options: deny
X-Robots-Tag: noindex
I think this problem have relation with null value in Entity.
/**
* #return Collection|null<int, Falta>
*/
public function getFalta(): ?Collection
{
return $this->falta;
}
It makes sense? And how fix this?
My complete entity:
<?php
declare(strict_types=1);
namespace App\Entity;
use ApiPlatform\Core\Annotation\ApiFilter;
use ApiPlatform\Core\Annotation\ApiResource;
use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\SearchFilter;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Annotation\Groups;
use Symfony\Component\Validator\Constraints as Assert;
/**
* #ORM\Entity
* #ORM\HasLifecycleCallbacks
* #ORM\Table(schema="db_automacao_sti", name="tb_pessoa")
*
* #ApiResource(
* normalizationContext={"groups"={"pessoa:read"}},
* denormalizationContext={"groups"={"pessoa:write"}},
* collectionOperations={
* "get"
* },
* itemOperations={
* "get"
* }
* )
* #ApiFilter(SearchFilter::class, properties={"ordemServicoContratoItemPessoa.itemContrato.contrato": "exact","ordemServicoContratoItemPessoa.itemContrato": "exact"})
*/
class Pessoa
{
/**
* #Groups({"pessoa:read"})
*
* #ORM\Id
* #ORM\Column(name="pk_pessoa", type="integer")
* #ORM\GeneratedValue(strategy="SEQUENCE")
* #ORM\SequenceGenerator(sequenceName="sq_pessoa", initialValue=1, allocationSize=100)
*/
private ?int $id = null;
/**
* #Groups({"pessoa:read"})
*
* #ORM\Column(name="dh_criado_em", type="datetime")
*/
private ?\DateTimeInterface $criadoEm = null;
/**
* #Groups({"pessoa:read"})
*
* #ORM\Column(name="dh_atualizado_em", type="datetime")
*/
private ?\DateTimeInterface $atualizadoEm = null;
/**
* #Assert\NotBlank
* #Assert\Type("\DateTimeInterface")
*
* #Groups({"pessoa:read", "pessoa:write"})
*
* #ORM\Column(name="dh_contratado_em", type="datetime")
*/
private ?\DateTimeInterface $contratadoEm = null;
/**
* #Assert\NotBlank
* #Assert\Length(max=255)
*
* #Groups({"pessoa:read", "pessoa:write"})
*
* #ORM\Column(name="no_pessoa", type="string", length=255)
*/
private ?string $nome = null;
/**
* #Assert\NotBlank
* #Assert\Length(11)
*
* #Groups({"pessoa:read", "pessoa:write"})
*
* #ORM\Column(name="nu_cpf", type="string", length=11)
*/
private ?string $cpf = null;
/**
* #Assert\NotBlank
* #Assert\Length(max=255)
* #Assert\Email
*
* #Groups({"pessoa:read", "pessoa:write"})
*
* #ORM\Column(name="ds_email", type="string", length=255)
*/
private ?string $email = null;
/**
* #Assert\NotBlank
* #Assert\Length(min=10, max=11)
* #Assert\Type("digit")
*
* #Groups({"pessoa:read", "pessoa:write"})
*
* #ORM\Column(name="nu_telefone", type="string", length=11)
*/
private ?string $numeroTelefone = null;
/**
* #var Collection<int, OrdemServicoContratoItemPessoa> Coleção de ordemServicoContratoItemPessoa
* #ORM\OneToMany(targetEntity="OrdemServicoContratoItemPessoa", mappedBy="pessoa")
*/
private $ordemServicoContratoItemPessoa;
/**
* #var Collection<int, Falta> Coleção de falta
* #ORM\OneToMany(targetEntity="Falta", mappedBy="pessoa")
* #Groups({"item:read"})
*/
private $falta;
/**
* #ORM\PrePersist
* #ORM\PreUpdate
*/
public function onPrePersistOrUpdate(): void
{
$this->setAtualizadoEm(new \DateTimeImmutable('now', new \DateTimeZone('UTC')));
if (null === $this->getCriadoEm()) {
$this->setCriadoEm(new \DateTimeImmutable('now', new \DateTimeZone('UTC')));
}
}
public function getId(): ?int
{
return $this->id;
}
public function getCriadoEm(): ?\DateTimeInterface
{
return $this->criadoEm;
}
public function setCriadoEm(\DateTimeInterface $criadoEm): self
{
$this->criadoEm = $criadoEm;
return $this;
}
public function getAtualizadoEm(): ?\DateTimeInterface
{
return $this->atualizadoEm;
}
public function setAtualizadoEm(\DateTimeInterface $atualizadoEm): self
{
$this->atualizadoEm = $atualizadoEm;
return $this;
}
public function getContratadoEm(): ?\DateTimeInterface
{
return $this->contratadoEm;
}
public function setContratadoEm(\DateTimeInterface $contratadoEm): self
{
$this->contratadoEm = $contratadoEm;
return $this;
}
public function getNome(): ?string
{
return $this->nome;
}
public function setNome(string $nome): self
{
$this->nome = $nome;
return $this;
}
public function getCpf(): ?string
{
return $this->cpf;
}
public function setCpf(string $cpf): self
{
$this->cpf = $cpf;
return $this;
}
public function getEmail(): ?string
{
return $this->email;
}
public function setEmail(string $email): self
{
$this->email = $email;
return $this;
}
public function getNumeroTelefone(): ?string
{
return $this->numeroTelefone;
}
public function setNumeroTelefone(string $numeroTelefone): self
{
$this->numeroTelefone = $numeroTelefone;
return $this;
}
/**
* #return Collection<int, OrdemServicoContratoItemPessoa>
*/
public function getOrdemServicoContratoItemPessoa(): Collection
{
return $this->ordemServicoContratoItemPessoa;
}
/**
* #return Collection|null<int, Falta>
*/
public function getFalta(): ?Collection
{
return $this->falta;
}
}

Answer 1

You are having an error because a Collection (ArrayCollection) is not initialized.
Add a constructor to your entity and set every collection value as a new ArrayCollection();
It should look like:
use Doctrine\Common\Collections\ArrayCollection;
public function __construct()
{
$this->ordemServicoContratoItemPessoa = new ArrayCollection();
$this->falta = new ArrayCollection();
}

Answer 2

It makes sense?
Yes, I'd say you've found the culprit that is causing the error.
And how fix this?
It needs to become anything iterable, null does not suffice (it is commonly not seen as an iterable, albeit this could be questionable in a one to many relationship if it allows one to none, it seems an oversight to not handle the case of null but this is a purely theoretical discussion).
Practically given your getter:
/**
* #return Collection|null<int, Falta>
*/
public function getFalta(): ?Collection
{
return $this->falta;
}
you can use the error to make it more obvious by making the return-type non-null:
/**
* #return Collection<int, Falta>
*/
public function getFalta(): Collection
{
return $this->falta;
}
(btw. null<XXX> would have been wrong anyway - null is not of any other type, that type template does not exist.)
Now PHP will directly highlight the illegal access. You won't need an additional assertion (as currently it is done when you run the tests).
TypeError: ...
Sounds counter-productive? No, first of all the return-type-hint you use in your production code is fixed. It exactly shows and documents which type is intended for the code to work - in its public interface (one of the best places to document such things).
In some languages this called "testing with the compiler", that is to make errors or flaws in the code visible early (we embrace errors). As in PHP there is no compiler, Unit-Tests are important so all code is at least executed once and then the type constraints in the runtime are applied. So to say "testing with the interpreter".
This should also make a concrete fix more obvious: If at that place and in time $this->falta is null, you need an empty collection:
/**
* #return Collection<int, Falta>
*/
public function getFalta(): Collection
{
return $this->falta ?? new ArrayCollection();
}
The default Collection Doctrine\Common\Collections\ArrayCollection is empty, so it can well represent that there is no data (previously null).
( Dylan Kas also pointed to this basic Collection which is easily available at hand in his answer that initializes it already in the constructor)
And you have "solved" the type problem.
How good is this fix you still need to ask yourself, so far it only solves the type problem. But the type problem might have hinted an initialization (or other) problem.
Fixing the problem too early might hide the actual problem (!). This is again why we embrace errors and provoke them until we have understood what we're doing here. And then in a glimpse of the eye suddenly things are clear, fixes are easy and we can throw away code we've been written previously (or well, this can happen).
I can not tell you if at the moment you get the error in test (or would get the error with the first fix suggestion for the return-type only - then in production) this is actually due to the fact that $this->falta must be non-null already. If so, let it fail and fix the actual reason.
This is what in the end should the testing give you.