Ejemplos de NailgunClientSession en Python

Ejemplo n.º 1

Archivo: test_nailgun_client.py Proyecto: lclementi/pants

    def setUp(self):
        self.client_sock, self.server_sock = socket.socketpair()

        self.fake_stdout = FakeFile()
        self.fake_stderr = FakeFile()

        self.nailgun_client_session = NailgunClientSession(
            sock=self.client_sock,
            in_fd=None,
            out_fd=self.fake_stdout,
            err_fd=self.fake_stderr)

        self.mock_reader = mock.create_autospec(InputReader, spec_set=True)
        self.nailgun_client_session._input_reader = self.mock_reader

Ejemplo n.º 2

Archivo: test_nailgun_client.py Proyecto: wisechengyi/pants

    def setUp(self):
        self.client_sock, self.server_sock = socket.socketpair()

        self.fake_stdout = FakeFile()
        self.fake_stderr = FakeFile()

        self.nailgun_client_session = NailgunClientSession(
            sock=self.client_sock,
            in_file=None,
            out_file=self.fake_stdout,
            err_file=self.fake_stderr,
        )

        self.mock_stdin_reader = unittest.mock.create_autospec(NailgunStreamWriter, spec_set=True)
        self.mock_stdin_reader.is_alive.side_effect = [False, True]
        self.nailgun_client_session._input_writer = self.mock_stdin_reader

Ejemplo n.º 3

Archivo: test_nailgun_client.py Proyecto: baroquebobcat/pants

  def setUp(self):
    self.client_sock, self.server_sock = socket.socketpair()

    self.fake_stdout = FakeFile()
    self.fake_stderr = FakeFile()

    self.nailgun_client_session = NailgunClientSession(
      sock=self.client_sock,
      in_file=None,
      out_file=self.fake_stdout,
      err_file=self.fake_stderr
    )

    self.mock_stdin_reader = mock.create_autospec(NailgunStreamWriter, spec_set=True)
    self.nailgun_client_session._input_writer = self.mock_stdin_reader

Ejemplo n.º 4

Archivo: test_nailgun_client.py Proyecto: wisechengyi/pants

class TestNailgunClientSession(unittest.TestCase):
    BAD_CHUNK_TYPE = b";"
    TEST_PAYLOAD = b"t e s t"
    TEST_WORKING_DIR = "/test_working_dir"
    TEST_MAIN_CLASS = "test_main_class"
    TEST_ARGUMENTS = [b"t", b"e", b"s", b"t"]
    TEST_ENVIRON = dict(TEST_ENV_VAR="xyz")

    def setUp(self):
        self.client_sock, self.server_sock = socket.socketpair()

        self.fake_stdout = FakeFile()
        self.fake_stderr = FakeFile()

        self.nailgun_client_session = NailgunClientSession(
            sock=self.client_sock,
            in_file=None,
            out_file=self.fake_stdout,
            err_file=self.fake_stderr,
        )

        self.mock_stdin_reader = unittest.mock.create_autospec(NailgunStreamWriter, spec_set=True)
        self.mock_stdin_reader.is_alive.side_effect = [False, True]
        self.nailgun_client_session._input_writer = self.mock_stdin_reader

    def tearDown(self):
        self.server_sock.close()
        self.client_sock.close()

    def test_input_writer_start_stop(self):
        self.nailgun_client_session._maybe_start_input_writer()
        self.mock_stdin_reader.start.assert_called_once_with()

        self.nailgun_client_session._maybe_stop_input_writer()
        self.mock_stdin_reader.stop.assert_called_once_with()

    def test_input_writer_noop(self):
        self.nailgun_client_session._input_writer = None
        self.nailgun_client_session._maybe_start_input_writer()
        self.nailgun_client_session._maybe_stop_input_writer()

    @unittest.mock.patch("psutil.Process", **PATCH_OPTS)
    def test_process_session(self, mock_psutil_process):
        mock_psutil_process.cmdline.return_value = ["mock", "process"]
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.PID, b"31337")
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.START_READING_INPUT)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDOUT, self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR, self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR, self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDOUT, self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR, self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.EXIT, b"1729")
        self.assertEqual(self.nailgun_client_session._process_session(), 1729)
        self.assertEqual(self.fake_stdout.content, self.TEST_PAYLOAD * 2)
        self.assertEqual(self.fake_stderr.content, self.TEST_PAYLOAD * 3)
        self.mock_stdin_reader.start.assert_called_once_with()
        self.mock_stdin_reader.stop.assert_called_once_with()
        self.assertEqual(self.nailgun_client_session.remote_pid, 31337)

    @unittest.mock.patch("psutil.Process", **PATCH_OPTS)
    def test_process_session_bad_chunk(self, mock_psutil_process):
        mock_psutil_process.cmdline.return_value = ["mock", "process"]
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.PID, b"31337")
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.START_READING_INPUT)
        NailgunProtocol.write_chunk(self.server_sock, self.BAD_CHUNK_TYPE, "")

        with self.assertRaises(NailgunClientSession.ProtocolError):
            self.nailgun_client_session._process_session()

        self.mock_stdin_reader.start.assert_called_once_with()
        self.mock_stdin_reader.stop.assert_called_once_with()

    @unittest.mock.patch.object(NailgunClientSession, "_process_session", **PATCH_OPTS)
    def test_execute(self, mock_process_session):
        mock_process_session.return_value = self.TEST_PAYLOAD
        out = self.nailgun_client_session.execute(
            self.TEST_WORKING_DIR, self.TEST_MAIN_CLASS, *self.TEST_ARGUMENTS, **self.TEST_ENVIRON
        )
        self.assertEqual(out, self.TEST_PAYLOAD)
        mock_process_session.assert_called_once_with(self.nailgun_client_session)

Ejemplo n.º 5

Archivo: test_nailgun_client.py Proyecto: lclementi/pants

class TestNailgunClientSession(unittest.TestCase):
    BAD_CHUNK_TYPE = b';'
    TEST_PAYLOAD = 't e s t'
    TEST_WORKING_DIR = '/test_working_dir'
    TEST_MAIN_CLASS = 'test_main_class'
    TEST_ARGUMENTS = ['t', 'e', 's', 't']
    TEST_ENVIRON = dict(TEST_ENV_VAR='xyz')

    def setUp(self):
        self.client_sock, self.server_sock = socket.socketpair()

        self.fake_stdout = FakeFile()
        self.fake_stderr = FakeFile()

        self.nailgun_client_session = NailgunClientSession(
            sock=self.client_sock,
            in_fd=None,
            out_fd=self.fake_stdout,
            err_fd=self.fake_stderr)

        self.mock_reader = mock.create_autospec(InputReader, spec_set=True)
        self.nailgun_client_session._input_reader = self.mock_reader

    def tearDown(self):
        self.server_sock.close()
        self.client_sock.close()

    def test_input_reader_running(self):
        with self.nailgun_client_session._input_reader_running():
            self.mock_reader.start.assert_called_once_with()
        self.mock_reader.stop.assert_called_once_with()

    def test_process_session(self):
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDOUT,
                                    self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR,
                                    self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR,
                                    self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDOUT,
                                    self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR,
                                    self.TEST_PAYLOAD)
        NailgunProtocol.write_chunk(self.server_sock, ChunkType.EXIT, '1729')
        self.assertEquals(self.nailgun_client_session._process_session(), 1729)
        self.assertEquals(self.fake_stdout.content, self.TEST_PAYLOAD * 2)
        self.assertEquals(self.fake_stderr.content, self.TEST_PAYLOAD * 3)

    def test_process_session_bad_chunk(self):
        NailgunProtocol.write_chunk(self.server_sock, self.BAD_CHUNK_TYPE, '')

        with self.assertRaises(NailgunClientSession.ProtocolError):
            self.nailgun_client_session._process_session()

    @mock.patch.object(NailgunClientSession, '_process_session', **PATCH_OPTS)
    @mock.patch.object(NailgunClientSession, '_input_reader_running',
                       **PATCH_OPTS)
    def test_execute(self, mctx, mproc):
        mproc.return_value = self.TEST_PAYLOAD
        out = self.nailgun_client_session.execute(self.TEST_WORKING_DIR,
                                                  self.TEST_MAIN_CLASS,
                                                  *self.TEST_ARGUMENTS,
                                                  **self.TEST_ENVIRON)
        self.assertEquals(out, self.TEST_PAYLOAD)
        mctx.assert_called_once_with(self.nailgun_client_session)
        mproc.assert_called_once_with(self.nailgun_client_session)

Ejemplo n.º 6

Archivo: test_nailgun_client.py Proyecto: baroquebobcat/pants

class TestNailgunClientSession(unittest.TestCase):
  BAD_CHUNK_TYPE = b';'
  TEST_PAYLOAD = 't e s t'
  TEST_WORKING_DIR = '/test_working_dir'
  TEST_MAIN_CLASS = 'test_main_class'
  TEST_ARGUMENTS = ['t', 'e', 's', 't']
  TEST_ENVIRON = dict(TEST_ENV_VAR='xyz')

  def setUp(self):
    self.client_sock, self.server_sock = socket.socketpair()

    self.fake_stdout = FakeFile()
    self.fake_stderr = FakeFile()

    self.nailgun_client_session = NailgunClientSession(
      sock=self.client_sock,
      in_file=None,
      out_file=self.fake_stdout,
      err_file=self.fake_stderr
    )

    self.mock_stdin_reader = mock.create_autospec(NailgunStreamWriter, spec_set=True)
    self.nailgun_client_session._input_writer = self.mock_stdin_reader

  def tearDown(self):
    self.server_sock.close()
    self.client_sock.close()

  def test_input_writer_start_stop(self):
    self.nailgun_client_session._maybe_start_input_writer()
    self.mock_stdin_reader.start.assert_called_once_with()

    self.nailgun_client_session._maybe_stop_input_writer()
    self.mock_stdin_reader.stop.assert_called_once_with()

  def test_input_writer_noop(self):
    self.nailgun_client_session._input_writer = None
    self.nailgun_client_session._maybe_start_input_writer()
    self.nailgun_client_session._maybe_stop_input_writer()

  def test_process_session(self):
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.PID, b'31337')
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.START_READING_INPUT)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDOUT, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDOUT, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.EXIT, b'1729')
    self.assertEquals(self.nailgun_client_session._process_session(), 1729)
    self.assertEquals(self.fake_stdout.content, self.TEST_PAYLOAD * 2)
    self.assertEquals(self.fake_stderr.content, self.TEST_PAYLOAD * 3)
    self.mock_stdin_reader.start.assert_called_once_with()
    self.mock_stdin_reader.stop.assert_called_once_with()
    self.assertEquals(self.nailgun_client_session.remote_pid, 31337)

  def test_process_session_bad_chunk(self):
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.PID, b'31337')
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.START_READING_INPUT)
    NailgunProtocol.write_chunk(self.server_sock, self.BAD_CHUNK_TYPE, '')

    with self.assertRaises(NailgunClientSession.ProtocolError):
      self.nailgun_client_session._process_session()

    self.mock_stdin_reader.start.assert_called_once_with()
    self.mock_stdin_reader.stop.assert_called_once_with()

  @mock.patch.object(NailgunClientSession, '_process_session', **PATCH_OPTS)
  def test_execute(self, mock_process_session):
    mock_process_session.return_value = self.TEST_PAYLOAD
    out = self.nailgun_client_session.execute(
      self.TEST_WORKING_DIR,
      self.TEST_MAIN_CLASS,
      *self.TEST_ARGUMENTS,
      **self.TEST_ENVIRON
    )
    self.assertEquals(out, self.TEST_PAYLOAD)
    mock_process_session.assert_called_once_with(self.nailgun_client_session)

Ejemplo n.º 7

Archivo: test_nailgun_client.py Proyecto: pall-valmundsson/pants

class TestNailgunClientSession(unittest.TestCase):
  BAD_CHUNK_TYPE = b';'
  TEST_PAYLOAD = b't e s t'
  TEST_WORKING_DIR = '/test_working_dir'
  TEST_MAIN_CLASS = 'test_main_class'
  TEST_ARGUMENTS = [b't', b'e', b's', b't']
  TEST_ENVIRON = dict(TEST_ENV_VAR='xyz')

  def setUp(self):
    self.client_sock, self.server_sock = socket.socketpair()

    self.fake_stdout = FakeFile()
    self.fake_stderr = FakeFile()

    self.nailgun_client_session = NailgunClientSession(
      sock=self.client_sock,
      in_file=None,
      out_file=self.fake_stdout,
      err_file=self.fake_stderr
    )

    self.mock_stdin_reader = mock.create_autospec(NailgunStreamWriter, spec_set=True)
    self.mock_stdin_reader.is_alive.side_effect = [False, True]
    self.nailgun_client_session._input_writer = self.mock_stdin_reader

  def tearDown(self):
    self.server_sock.close()
    self.client_sock.close()

  def test_input_writer_start_stop(self):
    self.nailgun_client_session._maybe_start_input_writer()
    self.mock_stdin_reader.start.assert_called_once_with()

    self.nailgun_client_session._maybe_stop_input_writer()
    self.mock_stdin_reader.stop.assert_called_once_with()

  def test_input_writer_noop(self):
    self.nailgun_client_session._input_writer = None
    self.nailgun_client_session._maybe_start_input_writer()
    self.nailgun_client_session._maybe_stop_input_writer()

  def test_process_session(self):
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.PID, b'31337')
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.START_READING_INPUT)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDOUT, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDOUT, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.STDERR, self.TEST_PAYLOAD)
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.EXIT, b'1729')
    self.assertEqual(self.nailgun_client_session._process_session(), 1729)
    self.assertEqual(self.fake_stdout.content, self.TEST_PAYLOAD * 2)
    self.assertEqual(self.fake_stderr.content, self.TEST_PAYLOAD * 3)
    self.mock_stdin_reader.start.assert_called_once_with()
    self.mock_stdin_reader.stop.assert_called_once_with()
    self.assertEqual(self.nailgun_client_session.remote_pid, 31337)

  def test_process_session_bad_chunk(self):
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.PID, b'31337')
    NailgunProtocol.write_chunk(self.server_sock, ChunkType.START_READING_INPUT)
    NailgunProtocol.write_chunk(self.server_sock, self.BAD_CHUNK_TYPE, '')

    with self.assertRaises(NailgunClientSession.ProtocolError):
      self.nailgun_client_session._process_session()

    self.mock_stdin_reader.start.assert_called_once_with()
    self.mock_stdin_reader.stop.assert_called_once_with()

  @mock.patch.object(NailgunClientSession, '_process_session', **PATCH_OPTS)
  def test_execute(self, mock_process_session):
    mock_process_session.return_value = self.TEST_PAYLOAD
    out = self.nailgun_client_session.execute(
      self.TEST_WORKING_DIR,
      self.TEST_MAIN_CLASS,
      *self.TEST_ARGUMENTS,
      **self.TEST_ENVIRON
    )
    self.assertEqual(out, self.TEST_PAYLOAD)
    mock_process_session.assert_called_once_with(self.nailgun_client_session)