push example

$route_provider = $this->createMock('Drupal\Core\Routing\RouteProviderInterface');
    $route_provider->expects($this->any())
      ->method('getRouteByName')
      ->with('test_route')
      ->willReturn(new Route('/test-path'));

    $this->urlGenerator = $this->createMock('Drupal\Core\Routing\UrlGeneratorInterface');
    $this->pathValidator = $this->createMock('Drupal\Core\Path\PathValidatorInterface');

    $this->requestStack = new RequestStack();
    $this->requestStack->push(new Request());

    $this->unroutedUrlAssembler = $this->createMock('Drupal\Core\Utility\UnroutedUrlAssemblerInterface');
    $this->linkGenerator = $this->createMock('Drupal\Core\Utility\LinkGeneratorInterface');

    $this->renderer = $this->createMock('Drupal\Core\Render\RendererInterface');

    $container_builder = new ContainerBuilder();
    $container_builder->set('url_generator', $this->urlGenerator);
    $container_builder->set('path.validator', $this->pathValidator);
    $container_builder->set('unrouted_url_assembler', $this->unroutedUrlAssembler);
    $container_builder->set('request_stack', $this->requestStack);
    

$this->getContainer()->get(CartPersister::class)->save($cart, $salesChannelContext);

        $this->getContainer()->get('product.repository')->delete([[
            'id' => $productId,
        ]], $context);

        $request = new Request();
        $session = $this->getSession();
        static::assertInstanceOf(Session::class, $session);
        $request->setSession($session);
        $this->getContainer()->get('request_stack')->push($request);

        $requestDataBag = new RequestDataBag();
        $requestDataBag->set('username', $customer->getEmail());
        $requestDataBag->set('password', 'test12345');

        $salesChannelContextNew = $this->getContainer()->get(SalesChannelContextFactory::class)->create(
            Uuid::randomHex(),
            TestDefaults::SALES_CHANNEL
        );

        $this->getContainer()->get(AuthController::class)->login($request, $requestDataBag, $salesChannelContextNew);
        

class ThemeAssetPackageTest extends TestCase
{
    /** * @dataProvider urlCases */
    public function testGetUrl(string $inputUrl, ?Request $request, string $expectedUrl): void
    {
        $requestStack = new RequestStack();

        if ($request instanceof Request) {
            $requestStack->push($request);
        }

        $themeAssetPackage = new ThemeAssetPackage(
            ['http://localhost'],
            new StaticVersionStrategy('v1'),
            $requestStack,
            new MD5ThemePathBuilder()
        );

        $actual = $themeAssetPackage->getUrl($inputUrl);

        

$profiler = $this->createMock(Profiler::class);
        $profiler->expects($this->once())
            ->method('collect')
            ->willReturn($profile);

        $kernel = $this->createMock(HttpKernelInterface::class);
        $mainRequest = $this->createMock(Request::class);
        $subRequest = $this->createMock(Request::class);
        $response = $this->createMock(Response::class);

        $requestStack = new RequestStack();
        $requestStack->push($mainRequest);

        $onlyException = true;
        $listener = new ProfilerListener($profiler, $requestStack, null, $onlyException);

        // main request         $listener->onKernelResponse(new ResponseEvent($kernel, $mainRequest, Kernel::MAIN_REQUEST, $response));

        // sub request         $listener->onKernelException(new ExceptionEvent($kernel, $subRequest, Kernel::SUB_REQUEST, new HttpException(404)));
        $listener->onKernelResponse(new ResponseEvent($kernel, $subRequest, Kernel::SUB_REQUEST, $response));

        

/** * {@inheritdoc} */
  protected function setUp(): void {
    parent::setUp();

    // The code under test uses transformRelative(), which relies on     // the Request containing the correct hostname. KernelTestBase doesn't set     // it, so push another request onto the stack to ensure it's correct.     $request = Request::create('/', 'GET', [], [], [], $_SERVER);
    $this->container = \Drupal::service('kernel')->getContainer();
    $this->container->get('request_stack')->push($request);

    $this->fileUrlGenerator = $this->container->get('file_url_generator');

    $this->testImages = [
      'core/misc/druplicon.png',
      'core/misc/loading.gif',
    ];
  }

  /** * Tests that an image with the sizes attribute is output correctly. */

$listener->onKernelResponse(new ResponseEvent($httpKernel, $request, HttpKernelInterface::MAIN_REQUEST, new Response()));
        $this->assertEmpty($dispatcher->getListeners());
    }

    protected function runSessionOnKernelResponse($newToken, $original = null)
    {
        $session = new Session(new MockArraySessionStorage());
        $request = new Request();
        $request->attributes->set('_security_firewall_run', '_security_session');
        $request->setSession($session);
        $requestStack = new RequestStack();
        $requestStack->push($request);

        if (null !== $original) {
            $session->set('_security_session', $original);
        }

        $factories = ['request_stack' => fn () => $requestStack];
        $tokenStorage = new UsageTrackingTokenStorage(new TokenStorage(), new class($factories) implements ContainerInterface {
            use ServiceLocatorTrait;
        });

        $tokenStorage->setToken($newToken);

        

$this->assertFormOptions($view, 'display_link_1');
    $this->assertFormOptions($view, 'display_link_2');

    // Assert the links are rendered correctly for all displays.     $this->assertRenderedDisplayLinks($view, 'page_1');
    $this->assertRenderedDisplayLinks($view, 'page_2');
    $this->assertRenderedDisplayLinks($view, 'block_1');

    // Assert some special request parameters are filtered from the display     // links.     $request_stack = new RequestStack();
    $request_stack->push(Request::create('page_1', 'GET', [
      'name' => 'John',
      'sort_by' => 'created',
      'sort_order' => 'ASC',
      'page' => 1,
      'keep' => 'keep',
      'keep_another' => 1,
      'view_name' => 1,
      'view_display_id' => 1,
      'view_args' => 1,
      'view_path' => 1,
      'view_dom_id' => 1,
      

    /** * @param array<string, string> $request */
    private function createRequest(array $request = []): Request
    {
        $request = new Request([], $request);
        $request->setSession($this->getSession());

        $requestStack = $this->getContainer()->get('request_stack');
        $requestStack->push($request);

        return $request;
    }
}

      // test running, but it is a problem when debugging. Also, disable SSL       // peer verification so that testing under HTTPS always works.       /** @var \GuzzleHttp\Client $client */
      $client = $this->container->get('http_client_factory')->fromOptions([
        'timeout' => NULL,
        'verify' => FALSE,
      ]);

      // Inject a Guzzle middleware to generate debug output for every request       // performed in the test.       $handler_stack = $client->getConfig('handler');
      $handler_stack->push($this->getResponseLogHandler());

      $driver->getClient()->setClient($client);
    }

    $selectors_handler = new SelectorsHandler([
      'hidden_field_selector' => new HiddenFieldSelector(),
    ]);
    $session = new Session($driver, $selectors_handler);
    $this->mink = new Mink();
    $this->mink->registerSession('default', $session);
    $this->mink->setDefaultSessionName('default');
    

        $customer = new CustomerEntity();
        $salesChannelContext = $this->createMock(SalesChannelContext::class);
        $salesChannelContext->method('getCustomer')->willReturn($customer);

        $request = new Request();
        $request->attributes->set(PlatformRequest::ATTRIBUTE_SALES_CHANNEL_CONTEXT_OBJECT, $salesChannelContext);
        $request->attributes->set(SalesChannelRequest::ATTRIBUTE_SALES_CHANNEL_MAINTENANCE, $active);
        $request->attributes->set(SalesChannelRequest::ATTRIBUTE_SALES_CHANNEL_MAINTENANCE_IP_WHITLELIST, \json_encode($whitelist, \JSON_THROW_ON_ERROR));
        $request->server->set('REMOTE_ADDR', self::IP);
        $requestStack->push($request);

        static::assertSame(self::IP, $request->getClientIp());

        $response = new Response();

        $event = new ResponseEvent(
            $this->createMock(HttpKernelInterface::class),
            $request,
            HttpKernelInterface::MAIN_REQUEST,
            $response
        );

        

  /** * Configures the stack using services tagged as http_client_middleware. * * @param \GuzzleHttp\HandlerStack $handler_stack * The handler stack */
  public function configure(HandlerStack $handler_stack) {
    $this->initializeMiddlewares();
    foreach ($this->middlewares as $middleware_id => $middleware) {
      $handler_stack->push($middleware, $middleware_id);
    }
  }

}

self::getRequest(true, false, true, false, false, true),
                false,
            ],
        ];
    }

    private function getRequestStack(?Request $main = null): RequestStack
    {
        $requestStack = new RequestStack();

        if ($main instanceof Request) {
            $requestStack->push($main);
        }

        return $requestStack;
    }

    /** * @param string[] $allowedIpAddresses */
    private static function getRequest(
        bool $useProxy,
        bool $isXmlHttpRequest,
        

class WhitespaceHandler implements HandlerInterface
{
    public function handle(Reader $reader, TokenStream $stream): bool
    {
        $match = $reader->findPattern('~^[ \t\r\n\f]+~');

        if (false === $match) {
            return false;
        }

        $stream->push(new Token(Token::TYPE_WHITESPACE, $match[0], $reader->getPosition()));
        $reader->moveForward(\strlen($match[0]));

        return true;
    }
}

        $this->config = $config;
    }

    public function __invoke(AdminSearchIndexingMessage $message): void
    {
        $indexer = $this->getIndexer($message->getEntity());

        $documents = $indexer->fetch($message->getIds());

        $this->push($indexer, $message->getIndices(), $documents, $message->getIds());
    }

    public static function getSubscribedEvents(): array
    {
        return [
            EntityWrittenContainerEvent::class => [
                ['refresh', -1000],
            ],
        ];
    }

    

/** * Tests the lock behavior. */
  public function testLocks() {
    $container = new ContainerBuilder();
    $container->set('module_handler', $this->createMock('Drupal\Core\Extension\ModuleHandlerInterface'));
    $container->set('current_user', $this->createMock('Drupal\Core\Session\AccountInterface'));
    $container->set('cache.test', $this->createMock('Drupal\Core\Cache\CacheBackendInterface'));
    $container->set('comment.statistics', $this->createMock('Drupal\comment\CommentStatisticsInterface'));
    $request_stack = new RequestStack();
    $request_stack->push(Request::create('/'));
    $container->set('request_stack', $request_stack);
    $container->setParameter('cache_bins', ['cache.test' => 'test']);
    $lock = $this->createMock('Drupal\Core\Lock\LockBackendInterface');
    $cid = 2;
    $lock_name = "comment:$cid:.00/";
    $lock->expects($this->once())
      ->method('acquire')
      ->with($lock_name, 30)
      ->willReturn(TRUE);
    $lock->expects($this->once())
      ->method('release')