Exemplo n.º 1
0
 def test_blocked_put_raises(self):
     """ A blocked put() should raise PipeClosed as soon as the pipe is closed
     """
     with gevent.Timeout(1):
         pipe = Pipe(0)
         g = gevent.spawn(_blocktest, pipe.put, None)
         while not pipe.putters:
             # Make sure pipe.put is blocking
             gevent.sleep(0)
         pipe.close()
         self.assertTrue(g.get(), 'pipe.put() did not raise PipeClosed as expected')
Exemplo n.º 2
0
    def test_file2pipe(self):
        with gevent.Timeout(1):
            file = open(self.TESTFILE, "r")
            pipe = Pipe()

            gevent.spawn_link_exception(file_to_pipe, file, pipe).join()

            result = "".join(chunk for chunk in pipe)

            self.assertTrue(file.closed)
            self.assertTrue(pipe.finished())

            self.assertEqual(result, self.get_content(self.TESTFILE))
Exemplo n.º 3
0
 def test_put_and_get_closed(self):
     with gevent.Timeout(1):
         pipe = Pipe()
         
         pipe.put(1)
         pipe.close()
         
         self.assertTrue(pipe.closed())
         self.assertFalse(pipe.finished())
         
         self.assertEqual(pipe.get_nowait(), 1)
 
         self.assertTrue(pipe.closed())
         self.assertTrue(pipe.finished())
         
         self.assertRaises(PipeClosed, pipe.get_nowait)
Exemplo n.º 4
0
    def test_pipe2file(self):
        with gevent.Timeout(1):
            pipe = Pipe()
            file = tempfile.NamedTemporaryFile(delete=False)

            try:
                pf = gevent.spawn_link_exception(pipe_to_file, pipe, file)

                with open(self.TESTFILE, "r") as infile:
                    for line in infile:
                        pipe.put(line)

                pipe.close()
                pf.join()

                self.assertTrue(file.closed)
                self.assertTrue(pipe.finished())

                self.assertEqualFiles(self.TESTFILE, file.name)

            finally:
                try:
                    os.remove(file.name)
                except:
                    pass
Exemplo n.º 5
0
 def test_empty(self):
     with gevent.Timeout(1):
         pipe = Pipe()
         
         self.assertFalse(pipe.closed())
         self.assertFalse(pipe.finished())
         
         pipe.close()
         
         self.assertTrue(pipe.closed())
         self.assertTrue(pipe.finished())
Exemplo n.º 6
0
    def test_put_to_closed_file(self):
        with gevent.Timeout(1):
            pipe = Pipe()
            file = open(os.devnull, "w")

            pf = gevent.spawn_link_exception(pipe_to_file, pipe, file)

            # Wait for pipe_to_file to block
            while not pipe.getters:
                gevent.sleep(0)

            # Close file
            file.close()

            # Write something to pipe
            pipe.put(".")

            # Wait for pipe_to_file process to end
            pf.join()

            # Pipe should be closed now
            self.assertTrue(pipe.closed())
Exemplo n.º 7
0
    def test_file2file(self):
        with gevent.Timeout(1):
            srcfile = open(self.TESTFILE, "r")
            pipe = Pipe(0)
            dstfile = tempfile.NamedTemporaryFile(delete=False)

            try:
                pf = gevent.spawn_link_exception(pipe_to_file, pipe, dstfile)
                fp = gevent.spawn_link_exception(file_to_pipe, srcfile, pipe, 64)

                gevent.joinall([fp, pf])

                self.assertTrue(srcfile.closed)
                self.assertTrue(dstfile.closed)
                self.assertTrue(pipe.finished())

                self.assertEqualFiles(self.TESTFILE, dstfile.name)

            finally:
                try:
                    os.remove(file.name)
                except:
                    pass
Exemplo n.º 8
0
 def test_put_raises_pipeclosed(self):
     with gevent.Timeout(1):
         pipe = Pipe()
         pipe.close()
         
         self.assertRaises(PipeClosed, pipe.put, 1)
Exemplo n.º 9
0
 def test_get_raises_pipeclosed(self):
     with gevent.Timeout(1):
         pipe = Pipe()
         pipe.close()
         
         self.assertRaises(PipeClosed, pipe.get_nowait)