InsertCommand example

    public function testPromotionCodeRequired(): void
    {
        $commands = [];
        $this->expectException(WriteException::class);

        $commands[] = new InsertCommand(
            $this->promotionDefinition,
            [
                'use_codes' => true,
                'use_individual_codes' => false,
                'code' => ' ',
            ],
            ['id' => 'D1'],
            $this->createMock(EntityExistence::class),
            '/0'
        );

        

        $event = EntityDeleteEvent::create(
            WriteContext::createFromContext(Context::createDefaultContext()),
            [
                new DeleteCommand(
                    new ProductDefinition(),
                    [
                        'id' => 'foo',
                    ],
                    new EntityExistence(ProductDefinition::ENTITY_NAME, ['id' => 'foo'], true, false, false, [])
                ),
                new InsertCommand(
                    new ProductReviewDefinition(),
                    ['id' => 'foo'],
                    ['id' => 'foo'],
                    new EntityExistence(ProductReviewDefinition::ENTITY_NAME, ['id' => 'foo'], true, false, false, []),
                    '/bar'
                ),
            ]
        );

        foreach ($event->getCommands() as $command) {
            static::assertInstanceOf(ChangeSetAware::class, $command);
            

'not-found' => [],
            ],
        ];
    }

    private static function insert(string $entity, array $primaryKey): InsertCommand
    {
        $definition = self::getDefinition($entity);

        $existence = new EntityExistence('', [], false, false, false, []);

        return new InsertCommand($definition, [], $primaryKey, $existence, '');
    }

    private static function delete(string $entity, array $primaryKey): DeleteCommand
    {
        $definition = self::getDefinition($entity);

        return new DeleteCommand($definition, $primaryKey, new EntityExistence('', [], false, false, false, []));
    }

    private static function getDefinition(string $entity): EntityDefinition
    {
        

$config->set('js.preprocess', TRUE)->save();
    $assert('Settings command exists when JS aggregation is enabled.');
  }

  /** * Checks empty content in commands does not throw exceptions. * * @doesNotPerformAssertions */
  public function testEmptyInsertCommand() {
    (new InsertCommand('foobar', []))->render();
  }

  /** * Asserts the array of Ajax commands contains the searched command. * * An AjaxResponse object stores an array of Ajax commands. This array * sometimes includes commands automatically provided by the framework in * addition to commands returned by a particular controller. During testing, * we're usually interested that a particular command is present, and don't * care whether other commands precede or follow the one we're interested in. * Additionally, the command we're interested in may include additional data * that we're not interested in. Therefore, this function simply asserts that * one of the commands in $haystack contains all of the keys and values in * $needle. Furthermore, if $needle contains a 'settings' key with an array * value, we simply assert that all keys and values within that array are * present in the command we're checking, and do not consider it a failure if * the actual command contains additional settings that aren't part of * $needle. * * @param array $haystack * An array of rendered Ajax commands returned by the server. * @param array $needle * Array of info we're expecting in one of those commands. * @param string $message * An assertion message. * * @internal */

static::assertFalse($command->hasField('available_stock'));
    }

    public function testThatAvailableStockIsCopiedOnInsert(): void
    {
        $context = Context::createDefaultContext();

        $subscriber = new AvailableStockMirrorSubscriber();

        $definition = $this->getDefinition();

        $command = new InsertCommand(
            $definition,
            ['stock' => 10],
            ['id' => $this->ids->getBytes('product-1')],
            new EntityExistence(
                ProductDefinition::ENTITY_NAME,
                ['id' => $this->ids->get('product-1')],
                false,
                false,
                false,
                []
            ),
            

$event = new PreWriteValidationEvent(WriteContext::createFromContext(Context::createDefaultContext()), [$inputCommand]);

        $subscriber = new ScheduledTaskCompatibilitySubscriber();
        $subscriber->addBackwardsCompatibility($event);

        static::assertEquals([$expectedCommand], $event->getCommands());
    }

    public function testSubscriberHasNoEffectWhenFeatureIsEnabled(): void
    {
        $dummyExistence = new EntityExistence('', [], true, true, true, []);
        $insertCommand = new InsertCommand(new ScheduledTaskDefinition(), [
            'id' => 'id',
            'name' => 'name',
            'run_interval' => 1,
        ], [], $dummyExistence, '');
        $event = new PreWriteValidationEvent(WriteContext::createFromContext(Context::createDefaultContext()), [$insertCommand]);

        $subscriber = new ScheduledTaskCompatibilitySubscriber();
        $subscriber->addBackwardsCompatibility($event);

        static::assertEquals([$insertCommand], $event->getCommands());
    }

    

static::assertEquals($expectedUpdate['newQuantity'], $changes[$i]->newQuantity);
                }

                return true;
            }));

        $orderItemDefinition = $this->getDefinition();

        $commands = array_map(
            function Darray $command) use ($orderItemDefinition, $idMapper) {
                return match ($command['type']) {
                    'insert' => new InsertCommand(
                        $orderItemDefinition,
                        [],
                        ['id' => $this->ids->getBytes($command['id'])],
                        new EntityExistence(
                            OrderLineItemDefinition::ENTITY_NAME,
                            ['id' => $this->ids->get($command['id'])],
                            false,
                            false,
                            false,
                            []
                        ),
                        

'data' => '<p>New Text!</p>',
      'settings' => ['my-setting' => 'setting'],
    ];

    $this->assertEquals($expected, $command->render());
  }

  /** * @covers \Drupal\Core\Ajax\InsertCommand */
  public function testInsertCommand() {
    $command = new InsertCommand('#page-title', '<p>New Text!</p>', ['my-setting' => 'setting']);

    $expected = [
      'command' => 'insert',
      'method' => NULL,
      'selector' => '#page-title',
      'data' => '<p>New Text!</p>',
      'settings' => ['my-setting' => 'setting'],
    ];

    $this->assertEquals($expected, $command->render());
  }

  

  public function renderArrayEarly() {
    $render_array = $this->earlyRenderContent();
    return [
      '#markup' => $this->renderer->render($render_array),
    ];
  }

  public function ajaxResponse() {
    $response = new AjaxResponse();
    $response->addCommand(new InsertCommand(NULL, $this->renderArray()));
    return $response;
  }

  public function ajaxResponseEarly() {
    $response = new AjaxResponse();
    $response->addCommand(new InsertCommand(NULL, $this->renderArrayEarly()));
    return $response;
  }

  public function response() {
    return new Response('Hello world!');
  }

$this->context = WriteContext::createFromContext(Context::createDefaultContext());

        $this->shippingMethodDefinition = new ShippingMethodDefinition();
    }

    /** * @dataProvider shippingMethodTaxProvider */
    public function testShippingMethodValidator(?string $taxType, ?string $taxId, bool $success): void
    {
        $commands = [];
        $commands[] = new InsertCommand(
            $this->shippingMethodDefinition,
            [
                'name' => 'test',
                'tax_type' => $taxType,
                'tax_id' => $taxId,
                'availability_rule' => [
                    'id' => Uuid::randomHex(),
                    'name' => 'asd',
                    'priority' => 2,
                ],
            ],
            [

array $pkData,
        array $data
    ): void {
        $queue = $parameterBag->getCommandQueue();

        if ($existence->exists()) {
            $queue->add($definition, new UpdateCommand($definition, $data, $pkData, $existence, $parameterBag->getPath()));

            return;
        }

        $queue->add($definition, new InsertCommand($definition, array_merge($pkData, $data), $pkData, $existence, $parameterBag->getPath()));
    }

    /** * @return Field[] */
    private function getFieldsInWriteOrder(EntityDefinition $definition): array
    {
        $fields = $definition->getFields();

        $filtered = [];

        

        $commitId = Uuid::randomBytes();

        $date = (new \DateTime())->format(Defaults::STORAGE_DATE_TIME_FORMAT);

        $source = $writeContext->getContext()->getSource();
        $userId = $source instanceof AdminApiSource && $source->getUserId()
            ? Uuid::fromHexToBytes($source->getUserId())
            : null;

        $insert = new InsertCommand(
            $this->versionCommitDefinition,
            [
                'id' => $commitId,
                'user_id' => $userId,
                'version_id' => Uuid::fromHexToBytes($versionId),
                'created_at' => $date,
            ],
            ['id' => $commitId],
            EntityExistence::createForEntity(
                $this->versionCommitDefinition->getEntityName(),
                ['id' => Uuid::fromBytesToHex($commitId)],
            ),

'not-found' => [],
            ],
        ];
    }

    private static function insert(string $entity, array $primaryKey): InsertCommand
    {
        $definition = self::getDefinition($entity);

        $existence = new EntityExistence('', [], false, false, false, []);

        return new InsertCommand($definition, [], $primaryKey, $existence, '');
    }

    private static function delete(string $entity, array $primaryKey): DeleteCommand
    {
        $definition = self::getDefinition($entity);

        return new DeleteCommand($definition, $primaryKey, new EntityExistence('', [], false, false, false, []));
    }

    private static function getDefinition(string $entity): EntityDefinition
    {
        

        $response->addCommand(new AlertCommand($error));
      }
    }

    $html = $this->renderer->renderRoot($main_content);
    $response->setAttachments($main_content['#attached']);

    // The selector for the insert command is NULL as the new content will     // replace the element making the Ajax call. The default 'replaceWith'     // behavior can be changed with #ajax['method'].     $response->addCommand(new InsertCommand(NULL, $html));
    $status_messages = ['#type' => 'status_messages'];
    $output = $this->renderer->renderRoot($status_messages);
    if (!empty($output)) {
      $response->addCommand(new PrependCommand(NULL, $output));
    }
    return $response;
  }

}