PHP Argument::cetera方法代码示例

 function it_lists_user_notifications_linked_to_the_current_user(UserInterface $user, UserNotification $userNotification, Request $request, $manager, $context, $templating)
 {
     $context->getUser()->willReturn($user);
     $manager->getUserNotifications($user, Argument::cetera())->willReturn([$userNotification]);
     $templating->renderResponse('PimNotificationBundle:Notification:list.json.twig', ['userNotifications' => [$userNotification]], Argument::type('Symfony\\Component\\HttpFoundation\\JsonResponse'))->shouldBeCalled();
     $this->listAction($request);
 }

 function it_processes_homogeneous_items($serializer, $localeRepository)
 {
     $items = [['item1' => ['attr10']], ['item2' => 'attr20'], ['item3' => ['attr30']]];
     $localeRepository->getActivatedLocaleCodes()->willReturn(['code1', 'code2']);
     $serializer->serialize(Argument::cetera())->willReturn('those;items;in;csv;format;');
     $this->process($items)->shouldReturn('those;items;in;csv;format;');
 }

 function it_builds_form(FormBuilderInterface $builder)
 {
     $builder->add('rating', 'choice', Argument::cetera())->willReturn($builder)->shouldBeCalled();
     $builder->add('title', 'text', Argument::cetera())->willReturn($builder)->shouldBeCalled();
     $builder->add('comment', 'textarea', Argument::cetera())->willReturn($builder)->shouldBeCalled();
     $this->buildForm($builder, ['rating_steps' => 5]);
 }

 function it_should_pre_load_configuration_properly(GenericEvent $event, ContainerInterface $container, PhpGuard $guard, InputInterface $input)
 {
     $input->hasParameterOption(Argument::cetera())->willReturn(false);
     $container->get('phpguard')->willReturn($guard);
     $guard->setOptions(array())->shouldBeCalled();
     $this->preLoad($event);
 }

 function it_does_not_notify_if_job_execution_has_no_user($event, $jobExecution, $manager)
 {
     $jobExecution->getUser()->willReturn(null);
     $jobExecution->getStatus()->shouldNotBeCalled();
     $manager->notify(Argument::cetera())->shouldNotBeCalled();
     $this->afterJobExecution($event);
 }

 function it_throws_an_exception_if_something_went_wrong_with_magento_calls(Category $category, $webservice, $categoryMappingManager)
 {
     $batches = [['create' => [['pimCategory' => $category, 'magentoCategory' => ['foo']]]]];
     $webservice->sendNewCategory(['foo'])->willThrow('\\Pim\\Bundle\\MagentoConnectorBundle\\Webservice\\SoapCallException');
     $categoryMappingManager->registerCategoryMapping(Argument::cetera())->shouldNotBeCalled();
     $this->shouldThrow('\\Akeneo\\Bundle\\BatchBundle\\Item\\InvalidItemException')->duringWrite($batches);
 }

 function it_creates_query_builder_for_all_status($em, QueryBuilder $builder)
 {
     $em->createQueryBuilder()->shouldBeCalled()->willReturn($builder);
     $builder->select('method')->shouldBeCalled()->willReturn($builder);
     $builder->from(Argument::any(), 'method', Argument::cetera())->shouldBeCalled()->willReturn($builder);
     $this->getQueryBuidlerForChoiceType(array('disabled' => true))->shouldReturn($builder);
 }

 function it_copies_simple_select_value_to_a_product_value($builder, $attrValidatorHelper, AttributeInterface $fromAttribute, AttributeInterface $toAttribute, ProductInterface $product1, ProductInterface $product2, ProductInterface $product3, ProductInterface $product4, ProductValueInterface $fromProductValue, ProductValueInterface $toProductValue, AttributeOptionInterface $attributeOption)
 {
     $fromLocale = 'fr_FR';
     $toLocale = 'fr_FR';
     $toScope = 'mobile';
     $fromScope = 'mobile';
     $fromAttribute->getCode()->willReturn('fromAttributeCode');
     $toAttribute->getCode()->willReturn('toAttributeCode');
     $attrValidatorHelper->validateLocale(Argument::cetera())->shouldBeCalled();
     $attrValidatorHelper->validateScope(Argument::cetera())->shouldBeCalled();
     $fromProductValue->getData()->willReturn($attributeOption);
     $toProductValue->setOption($attributeOption)->shouldBeCalledTimes(3);
     $product1->getValue('fromAttributeCode', $fromLocale, $fromScope)->willReturn($fromProductValue);
     $product1->getValue('toAttributeCode', $toLocale, $toScope)->willReturn($toProductValue);
     $product2->getValue('fromAttributeCode', $fromLocale, $fromScope)->willReturn(null);
     $product2->getValue('toAttributeCode', $toLocale, $toScope)->willReturn($toProductValue);
     $product3->getValue('fromAttributeCode', $fromLocale, $fromScope)->willReturn($fromProductValue);
     $product3->getValue('toAttributeCode', $toLocale, $toScope)->willReturn(null);
     $product4->getValue('fromAttributeCode', $fromLocale, $fromScope)->willReturn($fromProductValue);
     $product4->getValue('toAttributeCode', $toLocale, $toScope)->willReturn($toProductValue);
     $builder->addProductValue($product3, $toAttribute, $toLocale, $toScope)->shouldBeCalledTimes(1)->willReturn($toProductValue);
     $products = [$product1, $product2, $product3, $product4];
     foreach ($products as $product) {
         $this->copyAttributeData($product, $product, $fromAttribute, $toAttribute, ['from_locale' => $fromLocale, 'to_locale' => $toLocale, 'from_scope' => $fromScope, 'to_scope' => $toScope]);
     }
 }

 function let(ChannelManager $channelManager, MediaManager $mediaManager, ProductValueNormalizer $productValueNormalizer, CategoryMappingManager $categoryMappingManager, AssociationTypeManager $associationTypeManager, MappingCollection $storeViewMapping, MappingCollection $categoryMapping, MappingCollection $attributeMapping, Product $product, ProductValue $productValue, ProductValue $imageValue, Channel $channel, Locale $localeFR, Locale $localeEN, Category $category)
 {
     $this->beConstructedWith($channelManager, $mediaManager, $productValueNormalizer, $categoryMappingManager, $associationTypeManager, 1, 4, 'currency', 'magento_url');
     $this->globalContext = ['attributeSetId' => 0, 'magentoAttributes' => [], 'magentoAttributesOptions' => [], 'storeViewMapping' => $storeViewMapping, 'magentoStoreViews' => [['code' => 'fr_fr']], 'defaultLocale' => 'default_locale', 'website' => 'website', 'channel' => 'channel', 'categoryMapping' => $categoryMapping, 'attributeCodeMapping' => $attributeMapping, 'create' => true, 'pimGrouped' => 'pim_grouped', 'created_date' => new \DateTime(), 'updated_date' => new \DateTime(), 'defaultStoreView' => 'default', 'smallImageAttribute' => 'small_image_attribute', 'baseImageAttribute' => 'image_attribute', 'thumbnailAttribute' => 'image_attribute'];
     $attributeMapping->getTarget('visibility')->willReturn('visibility');
     $attributeMapping->getTarget('created_at')->willReturn('created_at');
     $attributeMapping->getTarget('updated_at')->willReturn('updated_at');
     $attributeMapping->getTarget('status')->willReturn('status');
     $attributeMapping->getTarget('categories')->willReturn('categories');
     $channelManager->getChannelByCode('channel')->willReturn($channel);
     $channel->getLocales()->willReturn([$localeEN, $localeFR]);
     $localeEN->getCode()->willReturn('default_locale');
     $localeFR->getCode()->willReturn('fr_FR');
     $channel->getCode()->willReturn('channel_code');
     $channel->getCategory()->willReturn($category);
     $product->getCategories()->willReturn([$category]);
     $product->getIdentifier()->willReturn('sku-000');
     $product->getCreated()->willReturn($this->globalContext['created_date']);
     $product->getUpdated()->willReturn($this->globalContext['updated_date']);
     $product->getValues()->willReturn(new ArrayCollection([$productValue, $imageValue]));
     $storeViewMapping->getTarget('default_locale')->willReturn('default_locale');
     $storeViewMapping->getTarget('fr_FR')->willReturn('fr_fr');
     $categoryMappingManager->getIdFromCategory($category, 'magento_url', $categoryMapping)->willReturn(2);
     $productValueNormalizer->normalize($productValue, Argument::cetera())->willReturn(['value' => 'productValueNormalized']);
     $productValueNormalizer->normalize($imageValue, Argument::cetera())->willReturn(null);
 }

 function it_does_not_report_screenshot_taking_not_supported_errors_on_screen(OutputInterface $output, Session $session, DriverInterface $driver)
 {
     $output->writeln(Argument::cetera())->shouldNotBeCalled();
     $driverInstance = $driver->getWrappedObject();
     $session->getScreenshot()->willThrow(new UnsupportedDriverActionException('Message.', $driverInstance));
     $this->takeScreenshot();
 }

 public function testPicksTheFirstSuitableResolverToResolveTheGivenValue()
 {
     $value = new FakeValue();
     $fixture = new FakeFixture();
     $set = ResolvedFixtureSetFactory::create();
     $scope = ['scope' => 'epocs'];
     $context = new GenerationContext();
     $context->markIsResolvingFixture('foo');
     $expected = new ResolvedValueWithFixtureSet(10, ResolvedFixtureSetFactory::create(null, null, (new ObjectBag())->with(new SimpleObject('dummy', new \stdClass()))));
     $instantiator1Prophecy = $this->prophesize(ChainableValueResolverInterface::class);
     $instantiator1Prophecy->canResolve($value)->willReturn(false);
     /* @var ChainableValueResolverInterface $instantiator1 */
     $instantiator1 = $instantiator1Prophecy->reveal();
     $instantiator2Prophecy = $this->prophesize(ChainableValueResolverInterface::class);
     $instantiator2Prophecy->canResolve($value)->willReturn(true);
     $instantiator2Prophecy->resolve($value, $fixture, $set, $scope, $context)->willReturn($expected);
     /* @var ChainableValueResolverInterface $instantiator2 */
     $instantiator2 = $instantiator2Prophecy->reveal();
     $instantiator3Prophecy = $this->prophesize(ChainableValueResolverInterface::class);
     $instantiator3Prophecy->canResolve(Argument::any())->shouldNotBeCalled();
     /* @var ChainableValueResolverInterface $instantiator3 */
     $instantiator3 = $instantiator3Prophecy->reveal();
     $registry = new ValueResolverRegistry([$instantiator1, $instantiator2, $instantiator3]);
     $actual = $registry->resolve($value, $fixture, $set, $scope, $context);
     $this->assertSame($expected, $actual);
     $instantiator1Prophecy->canResolve(Argument::any())->shouldHaveBeenCalledTimes(1);
     $instantiator2Prophecy->canResolve(Argument::any())->shouldHaveBeenCalledTimes(1);
     $instantiator2Prophecy->resolve(Argument::cetera())->shouldHaveBeenCalledTimes(1);
 }

 /**
  * @test
  */
 public function exceptionWhileParsingLongUrlOutputsError()
 {
     $this->urlShortener->urlToShortCode(Argument::cetera())->willThrow(new InvalidUrlException())->shouldBeCalledTimes(1);
     $this->commandTester->execute(['command' => 'shortcode:generate', 'longUrl' => 'http://domain.com/invalid']);
     $output = $this->commandTester->getDisplay();
     $this->assertTrue(strpos($output, 'Provided URL "http://domain.com/invalid" is invalid. Try with a different one.') === 0);
 }

 /**
  * @test
  */
 public function alreadyProcessedElementsAreNotProcessed()
 {
     $url = 'http://foo.com';
     $this->filesystem->exists(sprintf('dir/preview_%s.png', urlencode($url)))->willReturn(true)->shouldBeCalledTimes(1);
     $this->image->saveAs(Argument::cetera())->shouldBeCalledTimes(0);
     $this->assertEquals(sprintf('dir/preview_%s.png', urlencode($url)), $this->generator->generatePreview($url));
 }

 function it_gets_form_from_class_name(Configuration $configuration, FormFactoryInterface $formFactory, FormInterface $form)
 {
     $formClass = 'spec\\Sylius\\Bundle\\ResourceBundle\\Controller\\TestFormType';
     $configuration->getFormType()->willReturn($formClass);
     $formFactory->create(Argument::type($formClass), Argument::cetera())->shouldBeCalled()->willReturn($form);
     $this->getForm()->shouldReturn($form);
 }

 function it_falls_back_to_decorated_template_locator_if_there_are_no_themes_active(FileLocatorInterface $decoratedFileLocator, ThemeContextInterface $themeContext, ThemeHierarchyProviderInterface $themeHierarchyProvider, TemplateReferenceInterface $template)
 {
     $themeContext->getTheme()->willReturn(null);
     $themeHierarchyProvider->getThemeHierarchy(null)->willReturn([]);
     $decoratedFileLocator->locate($template, Argument::cetera())->willReturn('/app/template/path');
     $this->locate($template)->shouldReturn('/app/template/path');
 }