getMockForAbstractClass example

'id' => 1,
      'langcode' => 'en',
      'uuid' => '3bb9ee60-bea5-4622-b89b-a63319d10b3a',
    ];
    $this->entityTypeId = $this->randomMachineName();

    $this->entityType = $this->createMock('\Drupal\Core\Entity\EntityTypeInterface');
    $this->entityType->expects($this->any())
      ->method('getListCacheTags')
      ->willReturn([$this->entityTypeId . '_list']);

    $this->entityTypeManager = $this->getMockForAbstractClass(EntityTypeManagerInterface::class);
    $this->entityTypeManager->expects($this->any())
      ->method('getDefinition')
      ->with($this->entityTypeId)
      ->willReturn($this->entityType);

    $this->uuid = $this->createMock('\Drupal\Component\Uuid\UuidInterface');

    $this->languageManager = $this->createMock('\Drupal\Core\Language\LanguageManagerInterface');
    $this->languageManager->expects($this->any())
      ->method('getLanguage')
      ->with('en')
      

protected function setUp(): void
    {
        $this->rule = new DaysSinceLastOrderRule();
    }

    public function testRuleDoesNotMatchWithWrongScope(): void
    {
        $rule = new DaysSinceLastOrderRule();
        $rule->assign(['count' => 2, 'operator' => Rule::OPERATOR_LT]);

        $result = $rule->match($this->getMockForAbstractClass(RuleScope::class));

        static::assertFalse($result);
    }

    public function testRuleMatchesWithDayBefore(): void
    {
        $checkoutContext = $this->createMock(SalesChannelContext::class);
        $customer = new CustomerEntity();

        $datetime = self::getTestTimestamp();

        

        ], $this->context);

        static::assertNotNull($this->conditionRepository->search(new Criteria([$id]), $this->context)->get($id));
    }

    public function testRuleDoesNotMatchWithWrongScope(): void
    {
        $rule = new OrderTotalAmountRule();
        $rule->assign(['amount' => 2, 'operator' => Rule::OPERATOR_LT]);

        $result = $rule->match($this->getMockForAbstractClass(RuleScope::class));

        static::assertFalse($result);
    }

    public function testCustomerMetaFieldSubscriberWithCompletedOrder(): void
    {
        /** @var EntityRepository $orderRepository */
        $orderRepository = $this->getContainer()->get('order.repository');
        /** @var EntityRepository $customerRepository */
        $customerRepository = $this->getContainer()->get('customer.repository');
        $defaultContext = Context::createDefaultContext();
        

/** * Test class for AbstractProxy. * * @author Drak <drak@zikula.org> */
class AbstractProxyTest extends TestCase
{
    protected MockObject&AbstractProxy $proxy;

    protected function setUp(): void
    {
        $this->proxy = $this->getMockForAbstractClass(AbstractProxy::class);
    }

    public function testGetSaveHandlerName()
    {
        $this->assertNull($this->proxy->getSaveHandlerName());
    }

    public function testIsSessionHandlerInterface()
    {
        $this->assertFalse($this->proxy->isSessionHandlerInterface());
        $sh = new SessionHandlerProxy(new \SessionHandler());
        

  public function testGetDataDefinition($is_multiple) {
    $data_type = 'valid';
    $mock_data_definition = $this->getMockBuilder(ContextDefinitionInterface::class)
      ->onlyMethods([
        'getConstraints',
        'setLabel',
        'setDescription',
        'setRequired',
        'setConstraints',
      ])
      ->getMockForAbstractClass();
    $mock_data_definition->expects($this->once())
      ->method('setLabel')
      ->willReturnSelf();
    $mock_data_definition->expects($this->once())
      ->method('setDescription')
      ->willReturnSelf();
    $mock_data_definition->expects($this->once())
      ->method('setRequired')
      ->willReturnSelf();
    $mock_data_definition->expects($this->once())
      ->method('getConstraints')
      

  protected function getMockSource() {
    $this->createMock('\Iterator');

    $class = 'Drupal\migrate\Plugin\migrate\source\SourcePluginBase';
    $source = $this->getMockBuilder($class)
      ->disableOriginalConstructor()
      ->onlyMethods(get_class_methods($class))
      ->getMockForAbstractClass();
    $source->expects($this->once())
      ->method('rewind')
      ->willReturn(TRUE);
    $source->expects($this->any())
      ->method('initializeIterator')
      ->willReturn([]);
    $source->expects($this->any())
      ->method('valid')
      ->will($this->onConsecutiveCalls(TRUE, FALSE));

    return $source;
  }

/** * Tests the form ID generation. * * @covers ::getFormId * * @dataProvider providerTestFormIds */
  public function testFormId($expected, $definition) {
    $this->entityType->set('entity_keys', ['bundle' => $definition['bundle']]);

    $entity = $this->getMockForAbstractClass('Drupal\Core\Entity\EntityBase', [[], $definition['entity_type']], '', TRUE, TRUE, TRUE, ['getEntityType', 'bundle']);

    $entity->expects($this->any())
      ->method('getEntityType')
      ->willReturn($this->entityType);
    $entity->expects($this->any())
      ->method('bundle')
      ->willReturn($definition['bundle']);

    $this->entityForm->setEntity($entity);
    $this->entityForm->setOperation($definition['operation']);

    

  public function createMockForContentEntity($definitions) {
    $content_entity_mock = $this->getMockBuilder('Drupal\Core\Entity\ContentEntityBase')
      ->disableOriginalConstructor()
      ->onlyMethods(['getTypedData'])
      ->getMockForAbstractClass();
    $typed_data = $this->prophesize(ComplexDataInterface::class);
    $typed_data->getProperties(TRUE)
      ->willReturn($definitions)
      ->shouldBeCalled();
    $content_entity_mock->expects($this->any())
      ->method('getTypedData')
      ->willReturn($typed_data->reveal());

    return $content_entity_mock;
  }

  

  protected $pager;

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

    $this->pager = $this->getMockBuilder('Drupal\views\Plugin\views\pager\PagerPluginBase')
      ->disableOriginalConstructor()
      ->getMockForAbstractClass();

    $view = $this->getMockBuilder('Drupal\views\ViewExecutable')
      ->disableOriginalConstructor()
      ->getMock();
    $display = $this->getMockBuilder('Drupal\views\Plugin\views\display\DisplayPluginBase')
      ->disableOriginalConstructor()
      ->getMock();

    $options = [
      'items_per_page' => 5,
      'offset' => 1,
    ];

$this->fieldDefinitions = [
      'id' => BaseFieldDefinition::create('integer'),
      'revision_id' => BaseFieldDefinition::create('integer'),
    ];

    $this->entityFieldManager->expects($this->any())
      ->method('getFieldDefinitions')
      ->with($this->entityTypeId, $this->bundle)
      ->willReturn($this->fieldDefinitions);

    $this->entity = $this->getMockForAbstractClass(ContentEntityBase::class, [$values, $this->entityTypeId, $this->bundle], '', TRUE, TRUE, TRUE, ['isNew']);
    $values['defaultLangcode'] = [LanguageInterface::LANGCODE_DEFAULT => LanguageInterface::LANGCODE_NOT_SPECIFIED];
    $this->entityUnd = $this->getMockForAbstractClass(ContentEntityBase::class, [$values, $this->entityTypeId, $this->bundle]);
  }

  /** * @covers ::isNewRevision * @covers ::setNewRevision */
  public function testIsNewRevision() {
    // Set up the entity type so that on the first call there is no revision key     // and on the second call there is one.

->method('getManager')
            ->with($this->equalTo($name))
            ->willReturn($em);

        return $manager;
    }

    private function getObjectManager($repository)
    {
        $em = $this->getMockBuilder(ObjectManager::class)
            ->onlyMethods(['getClassMetadata', 'getRepository'])
            ->getMockForAbstractClass();
        $em->expects($this->any())
            ->method('getRepository')
            ->willReturn($repository);

        return $em;
    }

    private function createSchema($em)
    {
        $schemaTool = new SchemaTool($em);
        $schemaTool->createSchema([
            

public function testEmptyStringIsValid()
    {
        $this->validator->validate('', new Uuid());

        $this->assertNoViolation();
    }

    public function testExpectsUuidConstraintCompatibleType()
    {
        $this->expectException(UnexpectedTypeException::class);
        $constraint = $this->getMockForAbstractClass(Constraint::class);

        $this->validator->validate('216fff40-98d9-11e3-a5e2-0800200c9a66', $constraint);
    }

    public function testExpectsStringCompatibleType()
    {
        $this->expectException(UnexpectedValueException::class);
        $this->validator->validate(new \stdClass(), new Uuid());
    }

    /** * @dataProvider getValidStrictUuids */

if (isset($params[1])) {
            $parent = $this->createMock(NodeInterface::class);
            $parent->method('getPath')->willReturn($params[1]);

            $constructorArgs[] = $parent;

            if (isset($params[2])) {
                $constructorArgs[] = $params[2];
            }
        }

        $node = $this->getMockForAbstractClass(BaseNode::class, $constructorArgs);

        $this->assertSame($expected, $node->getPath());
    }

    public static function providePath(): array
    {
        return [
            'name only' => ['root', ['root']],
            'name and parent' => ['foo.bar.baz.bim', ['bim', 'foo.bar.baz']],
            'name and separator' => ['foo', ['foo', null, '/']],
            'name, parent and separator' => ['foo.bar/baz/bim', ['bim', 'foo.bar/baz', '/']],
        ];

$list_item_1 = $this->createMock('Drupal\Core\TypedData\TypedDataInterface');
    $list_item_2 = $this->createMock('Drupal\Core\TypedData\TypedDataInterface');

    $definitions = [
      'field_1' => $list_item_1,
      'field_2' => $list_item_2,
    ];

    $content_entity = $this->getMockBuilder('Drupal\Core\Entity\ContentEntityBase')
      ->disableOriginalConstructor()
      ->onlyMethods(['getFields'])
      ->getMockForAbstractClass();
    $content_entity->expects($this->once())
      ->method('getFields')
      ->willReturn($definitions);

    $serializer = $this->getMockBuilder('Symfony\Component\Serializer\Serializer')
      ->disableOriginalConstructor()
      ->onlyMethods(['normalize'])
      ->getMock();
    $serializer->expects($this->exactly(2))
      ->method('normalize')
      ->withConsecutive(
        [

/** * @coversDefaultClass \Drupal\Component\Plugin\PluginBase * @group Plugin */
class PluginBaseTest extends TestCase {

  /** * @dataProvider providerTestGetPluginId * @covers ::getPluginId */
  public function testGetPluginId($plugin_id, $expected) {
    $plugin_base = $this->getMockForAbstractClass('Drupal\Component\Plugin\PluginBase', [
      [],
      $plugin_id,
      [],
    ]);

    $this->assertEquals($expected, $plugin_base->getPluginId());
  }

  /** * Returns test data for testGetPluginId(). * * @return array */