Symfony 4: Test DB for JWT and Behat

Question

I am using API Platform 2.1 with Symfony 4 and I am using the LexikJWTAuthenticationBundle for authentication, and Behat for testing.

I am unable to set things up properly. Here is my configuration so far:

Feature: Books feature

@createSchema @dropSchema
Scenario: Adding a new book
  When I add "Content-Type" header equal to "application/json"
  And I add "Accept" header equal to "application/json"
  And I send a "POST" request to "/api/books" with body:
  """
 {
    "title": "King",
    "author": "T. M. Frazier",
    "enabled": true
 }
 """
 Then the response status code should be 201
 And the response should be in JSON
 And the header "Content-Type" should be equal to "application/json"
 And the JSON nodes should contain:
    | title                   | King              |
    | author                  | T. M. Frazier     |
 And the JSON node "enabled" should be true

Here is my feature context:

<?php

use Behat\Behat\Context\Context;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\KernelInterface;
use Behat\Behat\Hook\Scope\BeforeScenarioScope;
use App\Entity\User;
use Behatch\Context\RestContext;
use Behat\Behat\Context\SnippetAcceptingContext;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\ORM\Tools\SchemaTool;


/**
 * This context class contains the definitions of the steps used by the demo 
 * feature file. Learn how to get started with Behat and BDD on Behat's website.
 * 
 * @see http://behat.org/en/latest/quick_start.html
 */
class FeatureContext implements Context, SnippetAcceptingContext
{
    /**
     * @var KernelInterface
     */
    private $kernel;

    private $manager;

    private $jwtManager;

    private $schemaTool;

    private $response;

    private $classes;

    private $restContext;

    public function __construct(KernelInterface $kernel,$manager,$jwtManager)
    {
        $this->kernel = $kernel;
        $this->manager = $manager->getManager();
        $this->jwtManager = $jwtManager;
        $this->schemaTool = new SchemaTool($this->manager);
        $this->classes = $this->manager->getMetadataFactory()->getAllMetadata();
    }

    /**
     * @When a demo scenario sends a request to :path
     */
    public function aDemoScenarioSendsARequestTo(string $path)
    {
        $this->response = $this->kernel->handle(Request::create($path, 'GET'));
    }

    /**
     * @Then the response should be received
     */
    public function theResponseShouldBeReceived()
    {
        if ($this->response === null) {
            throw new \RuntimeException('No response received');
        }
    }

    /**
     * @BeforeScenario @createSchema
     */
    public function createDatabase()
    {
        $this->schemaTool->createSchema($this->classes);
    }

    /**
     * @AfterScenario @dropSchema
     */
    public function dropDatabase()
    {
        $this->schemaTool->dropSchema($this->classes);
    }

    /**
     * @BeforeScenario
     * @login
     *
     * @see https://symfony.com/doc/current/security/entity_provider.html#creating-your-first-user
     */
    public function login(BeforeScenarioScope $scope)
    {
        $user = new User();
        $user->setUsername('admin');
        $user->setPassword('ATestPassword');
        $user->setEmail('test@test.com');

        $this->manager->persist($user);
        $this->manager->flush();

        $token = $this->jwtManager->create($user);

        $this->restContext = $scope->getEnvironment()->getContext(RestContext::class);
        $this->restContext->iAddHeaderEqualTo('Authorization', "Bearer $token");
    }

    /**
     * @AfterScenario
     * @logout
     */
    public function logout() {
        $this->restContext->iAddHeaderEqualTo('Authorization', '');
    }
}

Now when executing vendor/bin/behat, it simply reads the .env file (dev environment) and tries to add an admin to my development database.

1) How do I ensure that a test db is created and the dev db is not used for testing? I have tried creating a .env.test with a different config but that didn't work.

2) even without the @login annotation above the scenario it reaches the login method from the FeatureContext. Is that how it is supposed to be?

3) I can't find proper documentation anywhere of how to set this up. The API Platform docs don't seem to be very helpful either. Reference: https://api-platform.com/docs/core/jwt/#jwt-authentication They talk about a createDB and dropDB, but it doesn't even exist anywhere. So I took it from another website. Is this the right way to do it?

Answer 1

I have no answer for 1) and 3), but for 2)

    /**
     * @BeforeScenario
     * @login
     */

should be on a single line, like so:

    /**
     * @BeforeScenario @login
     */