createStub example

use Symfony\Component\RateLimiter\LimiterInterface;
use Symfony\Component\RateLimiter\RateLimit;

class AbstractRequestRateLimiterTest extends TestCase
{
    /** * @dataProvider provideRateLimits */
    public function testConsume(array $rateLimits, ?RateLimit $expected)
    {
        $rateLimiter = new MockAbstractRequestRateLimiter(array_map(function DRateLimit $rateLimit) {
            $limiter = $this->createStub(LimiterInterface::class);
            $limiter->method('consume')->willReturn($rateLimit);

            return $limiter;
        }, $rateLimits));

        $this->assertSame($expected, $rateLimiter->consume(new Request()));
    }

    public static function provideRateLimits()
    {
        $now = new \DateTimeImmutable();

        

$migration = MigrationLookup::create($this->prepareContainer(), $configuration, '', [], $migration_plugin->reveal());
    $result = $migration->transform(1, $this->migrateExecutable, $this->row, '');
    $this->assertNull($result);
  }

  /** * @covers ::transform */
  public function testTransformWithStubbing() {
    $migration_plugin = $this->prophesize(MigrationInterface::class);
    $this->migrateLookup->lookup('destination_migration', [1])->willReturn(NULL);
    $this->migrateStub->createStub('destination_migration', [1], [], FALSE)->willReturn([2]);

    $configuration = [
      'no_stub' => FALSE,
      'migration' => 'destination_migration',
    ];

    $migration = MigrationLookup::create($this->prepareContainer(), $configuration, '', [], $migration_plugin->reveal());
    $result = $migration->transform(1, $this->migrateExecutable, $this->row, '');
    $this->assertEquals(2, $result);

    $this->migrateStub->createStub('destination_migration', [1], [], FALSE)->willThrow(new \Exception('Oh noes!'));
    

        parent::setUp();
        $this->context = $this->createMock(SalesChannelContext::class);
        $this->eventDispatcher = $this->createMock(EventDispatcherInterface::class);
        $this->customerRepository = $this->createMock(EntityRepository::class);
        $this->validator = $this->createMock(DataValidator::class);
        $this->salesChannelContextPersister = $this->createMock(SalesChannelContextPersister::class);

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

        $this->salesChannelContextService = $this->createStub(SalesChannelContextServiceInterface::class);
        $this->salesChannelContextService
            ->method('get')
            ->willReturn($newSalesChannelContext);

        $this->route = new RegisterConfirmRoute(
            $this->customerRepository,
            $this->eventDispatcher,
            $this->validator,
            $this->salesChannelContextPersister,
            $this->salesChannelContextService
        );
    }

    public function testSetResponseCacheOnLogin(
        string $route,
        string $requestMethod,
        int $cookiesAmount,
        string $cookieName,
        string $assertCountErrorMessage,
        string $assertEqualsErrorMessage
    ): void {
        $subscriber = new CacheResponseSubscriber(
            $this->createStub(CartService::class),
            100,
            true,
            new MaintenanceModeResolver(new RequestStack(), new CoreMaintenanceModeResolver(new EventDispatcher())),
            false,
            null,
            null
        );

        $salesChannelContext = $this->createStub(SalesChannelContext::class);
        $salesChannelContext
            ->method('getCustomer')
            

$this->validator,
            $this->definitionInstanceRegistry
        );
    }

    public function testEncodeMethodWithCorrectDataWillReturnDateIntervalString(): void
    {
        $data = new KeyValuePair('key', new \DateInterval('P2Y5D'), false);

        $iterator = $this->dateIntervalFieldSerializer->encode(
            new DateIntervalField('fake', 'fake'),
            $this->createStub(EntityExistence::class),
            $data,
            $this->createMock(WriteParameterBag::class)
        );

        $dateIntervalString = $iterator->current();

        \iterator_to_array($iterator);

        static::assertIsString($dateIntervalString);
        static::assertMatchesRegularExpression(self::REGEX_DATE_INTERVAL_VALIDATION, $dateIntervalString);
        static::assertEquals('P2Y0M5DT0H0M0S', $dateIntervalString);
    }

'url',
                'languageId',
                'currencyId',
                'name',
            ]
        );

        $input = $this->createMock(InputInterface::class);
        $input->method('getOption')
            ->willReturn(...$inputs);

        $output = $this->createStub(OutputInterface::class);

        $status = $cmd->run($input, $output);

        static::assertEquals(SalesChannelCreateStorefrontCommand::SUCCESS, $status);
    }

    /** * @param array<IdSearchResult> $idsSearchResult * * @dataProvider dataProviderTestExecuteCommandWithAnException */
    

$stub_migration = $this->migration->id();
      }
      elseif (isset($this->configuration['stub_id'])) {
        $stub_migration = $this->configuration['stub_id'];
      }
      else {
        $stub_migration = reset($lookup_migration_ids);
      }
      // Rethrow any exception as a MigrateException so the executable can shut       // down the migration.       try {
        $destination_ids = $this->migrateStub->createStub($stub_migration, $source_id_values[$stub_migration], [], FALSE);
      }
      catch (\LogicException $e) {
        // For BC reasons, we must allow attempting to stub a derived migration.       }
      catch (PluginNotFoundException $e) {
        // For BC reasons, we must allow attempting to stub a non-existent         // migration.       }
      catch (MigrateException $e) {
        throw $e;
      }
      

$migration->getIdMap()->willReturn($id_map->reveal());
    $migration->getDestinationPlugin(TRUE)->willReturn($destination_plugin->reveal());
    $migration->getProcessPlugins([])->willReturn([]);
    $migration->getProcess()->willReturn([]);
    $migration->getSourceConfiguration()->willReturn([]);
    $migration->getSourcePlugin()->willReturn($source_plugin->reveal());

    $this->migrationPluginManager->createInstances(['test_migration'])->willReturn([$migration->reveal()]);

    $stub = new MigrateStub($this->migrationPluginManager->reveal());

    $this->assertSame(['id' => 2], $stub->createStub('test_migration', ['id' => 1], []));
  }

  /** * Tests that an error is logged if the plugin manager throws an exception. */
  public function testExceptionOnPluginNotFound() {
    $this->migrationPluginManager->createInstances(['test_migration'])->willReturn([]);
    $this->expectException(PluginNotFoundException::class);
    $this->expectExceptionMessage("Plugin ID 'test_migration' was not found.");
    $stub = new MigrateStub($this->migrationPluginManager->reveal());
    $stub->createStub('test_migration', [1]);
  }

$this->installEntitySchema('user');
    $this->installSchema('node', 'node_access');
    $this->installConfig(['node', 'user']);
    $this->createContentType(['type' => 'node_lookup']);
  }

  /** * Tests stub creation. */
  public function testCreateStub() {
    $this->assertSame([], $this->migrateLookup->lookup('sample_stubbing_migration', [17]));
    $ids = $this->migrateStub->createStub('sample_stubbing_migration', [17]);
    $this->assertSame([$ids], $this->migrateLookup->lookup('sample_stubbing_migration', [17]));
    $this->assertNotNull(\Drupal::entityTypeManager()->getStorage('node')->load($ids['nid']));
  }

  /** * Tests raw stub creation. */
  public function testCreateStubRawReturn() {
    $this->assertSame([], $this->migrateLookup->lookup('sample_stubbing_migration', [17]));
    $ids = $this->migrateStub->createStub('sample_stubbing_migration', [17], [], FALSE);
    $this->assertSame($ids, [$this->migrateLookup->lookup('sample_stubbing_migration', [17])[0]['nid']]);
    

protected function setUp(): void
    {
        $this->cacheDir = $this->getKernel()->getCacheDir() . '/twig_test_' . microtime();
        $this->cache = new FilesystemCache($this->cacheDir);
    }

    /** * @dataProvider cartProvider */
    public function testAddCartErrorsAddsUrlToSalutationErrors(Cart $cart): void
    {
        $container = static::createStub(ContainerInterface::class);

        $container->method('get')
            ->willReturnMap([
                $this->getRequestStack(),
                $this->getRouter(),
                $this->getTranslator($cart->getErrors()),
            ]);

        $controller = new TestController();

        $controller->setContainer($container);
        

use Symfony\Component\HttpKernel\Controller\TraceableArgumentResolver;
use Symfony\Component\Stopwatch\Stopwatch;
use Symfony\Component\Stopwatch\StopwatchEvent;

class TraceableArgumentResolverTest extends TestCase
{
    public function testStopwatchEventIsStoppedWhenResolverThrows()
    {
        $stopwatchEvent = $this->createMock(StopwatchEvent::class);
        $stopwatchEvent->expects(self::once())->method('stop');

        $stopwatch = $this->createStub(Stopwatch::class);
        $stopwatch->method('start')->willReturn($stopwatchEvent);

        $resolver = new class() implements ArgumentResolverInterface {
            public function getArguments(Request $request, callable $controller): array
            {
                throw new \Exception();
            }
        };

        $traceableResolver = new TraceableArgumentResolver($resolver, $stopwatch);

        

use Symfony\Component\HttpKernel\Controller\TraceableControllerResolver;
use Symfony\Component\Stopwatch\Stopwatch;
use Symfony\Component\Stopwatch\StopwatchEvent;

class TraceableControllerResolverTest extends TestCase
{
    public function testStopwatchEventIsStoppedWhenResolverThrows()
    {
        $stopwatchEvent = $this->createMock(StopwatchEvent::class);
        $stopwatchEvent->expects(self::once())->method('stop');

        $stopwatch = $this->createStub(Stopwatch::class);
        $stopwatch->method('start')->willReturn($stopwatchEvent);

        $resolver = new class() implements ControllerResolverInterface {
            public function getController(Request $request): callable|false
            {
                throw new \Exception();
            }
        };

        $traceableResolver = new TraceableControllerResolver($resolver, $stopwatch);
        try {
            

\Closure::fromCallable(function D) {}), 'closure'],
            [[#[\Closure(name: FooListener::class)] static fn () => new FooListener(), 'listen'], 'Symfony\Component\EventDispatcher\Tests\Debug\FooListener::listen'],         ];
    }

    public function testStopwatchEventIsStoppedWhenListenerThrows()
    {
        $stopwatchEvent = $this->createMock(StopwatchEvent::class);
        $stopwatchEvent->expects(self::once())->method('isStarted')->willReturn(true);
        $stopwatchEvent->expects(self::once())->method('stop');

        $stopwatch = $this->createStub(Stopwatch::class);
        $stopwatch->method('start')->willReturn($stopwatchEvent);

        $dispatcher = $this->createStub(EventDispatcherInterface::class);

        $wrappedListener = new WrappedListener(static fn () => throw new \Exception(), null, $stopwatch, $dispatcher);

        try {
            $wrappedListener(new \stdClass(), 'foo', $dispatcher);
        } catch (\Exception $ex) {
        }
    }
}

#[Package('buyers-experience')] class NavigationPageSeoUrlRouteTest extends TestCase
{
    public function testPrepareCriteria(): void
    {
        $navigationPageSeoUrlRoute = new NavigationPageSeoUrlRoute(
            new CategoryDefinition(),
            static::createStub(CategoryBreadcrumbBuilder::class)
        );

        $salesChannel = new SalesChannelEntity();

        $criteria = new Criteria();
        $navigationPageSeoUrlRoute->prepareCriteria($criteria, $salesChannel);

        $filters = $criteria->getFilters();
        static::assertCount(2, $filters);

        $notFilter = $filters[0];
        

new BootstrapFlashMessageImportanceMapper(), Notification::IMPORTANCE_URGENT, 'danger'],
            [new BootstrapFlashMessageImportanceMapper(), Notification::IMPORTANCE_HIGH, 'warning'],
            [new BootstrapFlashMessageImportanceMapper(), Notification::IMPORTANCE_MEDIUM, 'info'],
            [new BootstrapFlashMessageImportanceMapper(), Notification::IMPORTANCE_LOW, 'success'],
        ];
    }

    private function buildBrowserChannel(Session $session, FlashMessageImportanceMapperInterface $mapper): BrowserChannel
    {
        $request = $this->createMock(Request::class);
        $request->method('getSession')->willReturn($session);
        $requestStack = $this->createStub(RequestStack::class);
        $requestStack->method('getCurrentRequest')->willReturn($request);

        return new BrowserChannel($requestStack, $mapper);
    }
}