How to assert that the database contains a value stored as JSON

The same problem, but i resolved it another way

$userSettings = UserSettings::find(1);
$this->assertEquals(['foo' => 'bar'], $userSettings->settings);

Are there any better solutions? Looks like a duct tape.

You have to first cast the value to JSON to be able to search for it in MySQL. I use the following helper method to do this:

/**
 * Generate a raw DB query to search for a JSON field.
 *
 * @param  array|json  $json
 *
 * @throws \Exception
 *
 * @return \Illuminate\Database\Query\Builder
 */
function castToJson($json)
{
    // Convert from array to json and add slashes, if necessary.
    if (is_array($json)) {
        $json = addslashes(json_encode($json));
    }
    // Or check if the value is malformed.
    elseif (is_null($json) || is_null(json_decode($json))) {
        throw new \Exception('A valid JSON string was not provided.');
    }
    return \DB::raw("CAST('{$json}' AS JSON)");
}

So, using my original example the database assertion would become:

$this->assertDatabaseHas('user_settings', [
    'id'       => 1,
    'user_id'  => 1,
    'settings' => castToJson('{"foo": "bar"}'),
]);

Hope that helps!

Thanks @talentia.

Here is a "simple" test i did with json that had factories involved...

$Location = factory(App\Models\Location::class)->make();
$Edited = factory(App\Models\Location::class)->make();
// create item
$this->actor->call('POST', 'locations', $Location->toArray());
// test edit
$response = $this->actor->call('PATCH', 'locations/1', $Edited->toArray());
// assert edited data exists...

        // assert Database Has does not handle json well...
        $test = $Edited->toArray();
        $test['json_data'] = castToJson($test['json_data']);
        $this->assertDatabaseHas('locations', $test);

    /**
     * @test
     */
    public function canUpdate()
    {
        $authUser = UserFactory::createDefault();
        $this->actingAs($authUser);

        $generator = GeneratorFactory::createDefault();

        $request = [
            'requires_data' => true,
            'documentation' => "99999",
            'prompters' => [
                'array-data',
                ['more-data' => 'cool'],
                'data' => 'some-data',
                'collectionA' => [
                    ['not-working' => 'cant-access'],
                    'data' => 'some-more-data'
                ],
                'collection' => [
                    ['data' => 'some-more-data']
                ]
            ],
            'file_modifiers' => [],
            'template_ids' => []
        ];

        $response = $this->putJson("/api/generators/{$generator->id}", $request);
        $response->assertOk();

        $this->assertDatabaseHas('generators', [
            'id' => $generator->id,
            'generator_set_id' => $generator->generatorSet->id,
            'requires_data' => true,
            'documentation' => 99999,
            'prompters->0' => 'array-data',
            'prompters->1->more-data' => 'cool',
            'prompters->data' => 'some-data',
            'prompters->collectionA->data' => 'some-more-data',
            'prompters->collectionA->0->not-working' => 'cant-access',
            'file_modifiers->0' => null,
        ]);
    }

@talentia @riabiy.denis @vitaly I know it is old question, but today I encountered same problem and my fast solution was:

/** @test */
function can_create_translatable_category()
{
//        $category = Category::factory()->raw();
    $category = Category::factory()->raw(
        [
            'title' => [
                'lt' => 'Darbas',
            ],
            'slug' => [
                'lt' => 'darbas',
            ]
        ]
    );

    $this->signIn(guard: 'admin')
        ->post(route('dashboard.admin.category.store'), $category)
        ->assertRedirect();

    $this->assertDatabaseHasJson('categories', $category);
}

TestCase.php

protected function assertDatabaseHasJson(string $table, array $data): TestCase
{
    collect($data)
        ->map(function ($item, $property) use (&$data) {
            if (is_array($item)) {
                collect($item)
                    ->map(function ($value, $key) use ($property, &$data) {
                        $data["$property->$key"] = $value;
                    });
                unset($data[$property]);
            }
        })
        ->toArray();

    return $this->assertDatabaseHas($table, $data);
}

If you are using json fields in your migrations:

$table->json('my_json_field');

And casting your JSON field in the model:

protected $casts = [
    "my_json_field" => "array",
];

Then a simplified version of the answer above should work:

protected function assertDatabaseHasJson(string $table, array $data)
{
    $dataArray = collect($data)->map(function ($item) {
        return is_array($item) ? $this->castAsJson($item) : $item;
    })->toArray();

    return $this->assertDatabaseHas($table, $dataArray);
}