bpo-33694: Remove test_asyncio ProactorDatagramTransportTests (GH-16288) · python/cpython@bc2256e (original) (raw)

`@@ -472,259 +472,6 @@ def test_dont_pause_writing(self):

472

`self.assertFalse(self.protocol.pause_writing.called)

473

474

475

@unittest.skip('FIXME: bpo-33694: these tests are too close '

476

'to the implementation and should be refactored or removed')

477

class ProactorSocketTransportBufferedProtoTests(test_utils.TestCase):

478

-

479

def setUp(self):

480

super().setUp()

481

self.loop = self.new_test_loop()

482

self.addCleanup(self.loop.close)

483

self.proactor = mock.Mock()

484

self.loop._proactor = self.proactor

485

-

486

self.protocol = test_utils.make_test_protocol(asyncio.BufferedProtocol)

487

self.buf = bytearray(1)

488

self.protocol.get_buffer.side_effect = lambda hint: self.buf

489

-

490

self.sock = mock.Mock(socket.socket)

491

-

492

def socket_transport(self, waiter=None):

493

transport = _ProactorSocketTransport(self.loop, self.sock,

494

self.protocol, waiter=waiter)

495

self.addCleanup(close_transport, transport)

496

return transport

497

-

498

def test_ctor(self):

499

fut = self.loop.create_future()

500

tr = self.socket_transport(waiter=fut)

501

test_utils.run_briefly(self.loop)

502

self.assertIsNone(fut.result())

503

self.protocol.connection_made(tr)

504

self.proactor.recv_into.assert_called_with(self.sock, self.buf)

505

-

506

def test_loop_reading(self):

507

tr = self.socket_transport()

508

tr._loop_reading()

509

self.loop._proactor.recv_into.assert_called_with(self.sock, self.buf)

510

self.assertTrue(self.protocol.get_buffer.called)

511

self.assertFalse(self.protocol.buffer_updated.called)

512

self.assertFalse(self.protocol.eof_received.called)

513

-

514

def test_get_buffer_error(self):

515

transport = self.socket_transport()

516

transport._fatal_error = mock.Mock()

517

-

518

self.loop.call_exception_handler = mock.Mock()

519

self.protocol.get_buffer.side_effect = LookupError()

520

-

521

transport._loop_reading()

522

-

523

self.assertTrue(transport._fatal_error.called)

524

self.assertTrue(self.protocol.get_buffer.called)

525

self.assertFalse(self.protocol.buffer_updated.called)

526

-

527

def test_get_buffer_zerosized(self):

528

transport = self.socket_transport()

529

transport._fatal_error = mock.Mock()

530

-

531

self.loop.call_exception_handler = mock.Mock()

532

self.protocol.get_buffer.side_effect = lambda hint: bytearray(0)

533

-

534

transport._loop_reading()

535

-

536

self.assertTrue(transport._fatal_error.called)

537

self.assertTrue(self.protocol.get_buffer.called)

538

self.assertFalse(self.protocol.buffer_updated.called)

539

-

540

def test_proto_type_switch(self):

541

self.protocol = test_utils.make_test_protocol(asyncio.Protocol)

542

tr = self.socket_transport()

543

-

544

res = self.loop.create_future()

545

res.set_result(b'data')

546

-

547

tr = self.socket_transport()

548

tr._read_fut = res

549

tr._loop_reading(res)

550

self.loop._proactor.recv.assert_called_with(self.sock, 32768)

551

self.protocol.data_received.assert_called_with(b'data')

552

-

553

switch protocol to a BufferedProtocol

554

-

555

buf_proto = test_utils.make_test_protocol(asyncio.BufferedProtocol)

556

buf = bytearray(4)

557

buf_proto.get_buffer.side_effect = lambda hint: buf

558

-

559

tr.set_protocol(buf_proto)

560

test_utils.run_briefly(self.loop)

561

res = self.loop.create_future()

562

res.set_result(4)

563

-

564

tr._read_fut = res

565

tr._loop_reading(res)

566

self.loop._proactor.recv_into.assert_called_with(self.sock, buf)

567

buf_proto.buffer_updated.assert_called_with(4)

568

-

569

@unittest.skip('FIXME: bpo-33694: this test is too close to the '

570

'implementation and should be refactored or removed')

571

def test_proto_buf_switch(self):

572

tr = self.socket_transport()

573

test_utils.run_briefly(self.loop)

574

self.protocol.get_buffer.assert_called_with(-1)

575

-

576

switch protocol to another BufferedProtocol

577

-

578

buf_proto = test_utils.make_test_protocol(asyncio.BufferedProtocol)

579

buf = bytearray(4)

580

buf_proto.get_buffer.side_effect = lambda hint: buf

581

tr._read_fut.done.side_effect = lambda: False

582

tr.set_protocol(buf_proto)

583

self.assertFalse(buf_proto.get_buffer.called)

584

test_utils.run_briefly(self.loop)

585

buf_proto.get_buffer.assert_called_with(-1)

586

-

587

def test_buffer_updated_error(self):

588

transport = self.socket_transport()

589

transport._fatal_error = mock.Mock()

590

-

591

self.loop.call_exception_handler = mock.Mock()

592

self.protocol.buffer_updated.side_effect = LookupError()

593

-

594

res = self.loop.create_future()

595

res.set_result(10)

596

transport._read_fut = res

597

transport._loop_reading(res)

598

-

599

self.assertTrue(transport._fatal_error.called)

600

self.assertFalse(self.protocol.get_buffer.called)

601

self.assertTrue(self.protocol.buffer_updated.called)

602

-

603

def test_loop_eof_received_error(self):

604

res = self.loop.create_future()

605

res.set_result(0)

606

-

607

self.protocol.eof_received.side_effect = LookupError()

608

-

609

tr = self.socket_transport()

610

tr._fatal_error = mock.Mock()

611

-

612

tr.close = mock.Mock()

613

tr._read_fut = res

614

tr._loop_reading(res)

615

self.assertFalse(self.loop._proactor.recv_into.called)

616

self.assertTrue(self.protocol.eof_received.called)

617

self.assertTrue(tr._fatal_error.called)

618

-

619

def test_loop_reading_data(self):

620

res = self.loop.create_future()

621

res.set_result(4)

622

-

623

tr = self.socket_transport()

624

tr._read_fut = res

625

tr._loop_reading(res)

626

self.loop._proactor.recv_into.assert_called_with(self.sock, self.buf)

627

self.protocol.buffer_updated.assert_called_with(4)

628

-

629

def test_loop_reading_no_data(self):

630

res = self.loop.create_future()

631

res.set_result(0)

632

-

633

tr = self.socket_transport()

634

self.assertRaises(AssertionError, tr._loop_reading, res)

635

-

636

tr.close = mock.Mock()

637

tr._read_fut = res

638

tr._loop_reading(res)

639

self.assertFalse(self.loop._proactor.recv_into.called)

640

self.assertTrue(self.protocol.eof_received.called)

641

self.assertTrue(tr.close.called)

642

-

643

def test_loop_reading_aborted(self):

644

err = self.loop._proactor.recv_into.side_effect = \

645

ConnectionAbortedError()

646

-

647

tr = self.socket_transport()

648

tr._fatal_error = mock.Mock()

649

tr._loop_reading()

650

tr._fatal_error.assert_called_with(

651

err, 'Fatal read error on pipe transport')

652

-

653

def test_loop_reading_aborted_closing(self):

654

self.loop._proactor.recv.side_effect = ConnectionAbortedError()

655

-

656

tr = self.socket_transport()

657

tr._closing = True

658

tr._fatal_error = mock.Mock()

659

tr._loop_reading()

660

self.assertFalse(tr._fatal_error.called)

661

-

662

def test_loop_reading_aborted_is_fatal(self):

663

self.loop._proactor.recv_into.side_effect = ConnectionAbortedError()

664

tr = self.socket_transport()

665

tr._closing = False

666

tr._fatal_error = mock.Mock()

667

tr._loop_reading()

668

self.assertTrue(tr._fatal_error.called)

669

-

670

def test_loop_reading_conn_reset_lost(self):

671

err = self.loop._proactor.recv_into.side_effect = ConnectionResetError()

672

-

673

tr = self.socket_transport()

674

tr._closing = False

675

tr._fatal_error = mock.Mock()

676

tr._force_close = mock.Mock()

677

tr._loop_reading()

678

self.assertFalse(tr._fatal_error.called)

679

tr._force_close.assert_called_with(err)

680

-

681

def test_loop_reading_exception(self):

682

err = self.loop._proactor.recv_into.side_effect = OSError()

683

-

684

tr = self.socket_transport()

685

tr._fatal_error = mock.Mock()

686

tr._loop_reading()

687

tr._fatal_error.assert_called_with(

688

err, 'Fatal read error on pipe transport')

689

-

690

def test_pause_resume_reading(self):

691

tr = self.socket_transport()

692

futures = []

693

for msg in [10, 20, 30, 40, 0]:

694

f = self.loop.create_future()

695

f.set_result(msg)

696

futures.append(f)

697

-

698

self.loop._proactor.recv_into.side_effect = futures

699

self.loop._run_once()

700

self.assertFalse(tr._paused)

701

self.assertTrue(tr.is_reading())

702

self.loop._run_once()

703

self.protocol.buffer_updated.assert_called_with(10)

704

self.loop._run_once()

705

self.protocol.buffer_updated.assert_called_with(20)

706

-

707

tr.pause_reading()

708

tr.pause_reading()

709

self.assertTrue(tr._paused)

710

self.assertFalse(tr.is_reading())

711

for i in range(10):

712

self.loop._run_once()

713

self.protocol.buffer_updated.assert_called_with(20)

714

-

715

tr.resume_reading()

716

tr.resume_reading()

717

self.assertFalse(tr._paused)

718

self.assertTrue(tr.is_reading())

719

self.loop._run_once()

720

self.protocol.buffer_updated.assert_called_with(30)

721

self.loop._run_once()

722

self.protocol.buffer_updated.assert_called_with(40)

723

tr.close()

724

-

725

self.assertFalse(tr.is_reading())

726

-

727

-

728

475

`class ProactorDatagramTransportTests(test_utils.TestCase):

729

476

730

477

`def setUp(self):