python类MagicMock()的实例源码

def testCreateSQLQueryModelWithUserInputWithExamplesAndTwoDataExamples(self):
    """test method CreateEventModelWithUserInput with examples"""

    fake_execution = fake_sqlite_query_execution.SQLQueryExecution(
        sql_query_data.SQLQueryData(
            has_error=False, data=['first', 'second'],
            columns=[type('columns', (object,), {'sql_column': 'id'}),
                     type('columns', (object,), {'sql_column': 'name'})])
    )
    sql_query = 'SELECT id from Users'
    name = 'Contact'
    with tempfile.TemporaryDirectory() as tmpdir:
      path = os.path.join(tmpdir, 'testfile')
      pathlib.Path(path).touch()

      output_handler = output_handler_file.OutputHandlerFile(
          path, file_handler.FileHandler(),
          confirm=True, confirm_amount_same=2, prompt_info=name)
      plugin_helper = fake_sqlite_plugin_helper.FakeSQLitePluginHelper(
          folder_exists=True)
      controller = sqlite_controller.SQLiteController(output_handler,
                                                      plugin_helper)
      controller.GetTimestamps = mock.MagicMock(return_value=([], []))
      actual = controller._CreateSQLQueryModelWithUserInput(sql_query, True,
                                                            fake_execution)
      prompt_output_actual = self._ReadFromFile(path)
      prompt_output_expected = ('Your query output could look like this.'
                                '[\'id\', \'name\']'
                                'first'
                                'second'
                                'Do you want to add this query?'
                                'Do you want to name the query parse row:  ?'
                                'Does the event  need customizing?')

      expected = sql_query_model.SQLQueryModel(
          sql_query, name, [], [], False, 0)

      self.assertEqual(actual.name, '')
      self.assertEqual(expected.query, actual.query)
      self.assertEqual(prompt_output_expected, prompt_output_actual)

def testCreateSQLQueryModelWithUserInputWithExamplesAndOneDataExamples(self):
    """test method CreateEventModelWithUserInput with examples"""

    fake_execution = fake_sqlite_query_execution.SQLQueryExecution(
        sql_query_data.SQLQueryData(
            has_error=False, data=['first'],
            columns=[type('columns', (object,), {'sql_column': 'id'}),
                     type('columns', (object,), {'sql_column': 'name'})])
    )
    sql_query = 'SELECT id from Users'
    name = 'Contact'
    with tempfile.TemporaryDirectory() as tmpdir:
      path = os.path.join(tmpdir, 'testfile')
      pathlib.Path(path).touch()

      output_handler = output_handler_file.OutputHandlerFile(
          path, file_handler.FileHandler(),
          confirm=True, confirm_amount_same=2, prompt_info=name)
      plugin_helper = fake_sqlite_plugin_helper.FakeSQLitePluginHelper(
          folder_exists=True)
      controller = sqlite_controller.SQLiteController(output_handler,
                                                      plugin_helper)
      controller.GetTimestamps = mock.MagicMock(return_value=([], []))
      actual = controller._CreateSQLQueryModelWithUserInput(sql_query, True,
                                                            fake_execution)
      prompt_output_actual = self._ReadFromFile(path)
      prompt_output_expected = ('Your query output could look like this.'
                                '[\'id\', \'name\']'
                                'first'
                                'Do you want to add this query?'
                                'Do you want to name the query parse row:  ?'
                                'Does the event  need customizing?')

      expected = sql_query_model.SQLQueryModel(sql_query, name, [], [], False,
                                               0)

      self.assertEqual(actual.name, '')
      self.assertEqual(expected.query, actual.query)
      self.assertEqual(prompt_output_expected, prompt_output_actual)

def testSqlQuery(self):
    """test method after getting the source path from the user"""
    with tempfile.TemporaryDirectory() as tmpdir:
      path = os.path.join(tmpdir, 'testfile')
      pathlib.Path(path).touch()

      output_handler = output_handler_file.OutputHandlerFile(
          path, file_handler.FileHandler(), confirm=False)
      plugin_helper = fake_sqlite_plugin_helper.FakeSQLitePluginHelper()
      controller = sqlite_controller.SQLiteController(output_handler,
                                                      plugin_helper)

      controller._CreateSQLQueryModelWithUserInput = mock.MagicMock(
          return_value=sql_query_data.SQLQueryData(
              data='test', has_error=False, error_message=None))

      actual = controller.SQLQuery(None, None, True)

      prompt_output_actual = self._ReadFromFile(path)

      prompt_output_expected = ('Please write your SQL script for the plugin'
                                'Do you want to add another Query?')

      self.assertEqual(len(actual), 1)
      self.assertEqual(actual[0].data, 'test')
      self.assertEqual(actual[0].has_error, False)
      self.assertEqual(actual[0].error_message, None)
      self.assertEqual(prompt_output_actual, prompt_output_expected)

def testSqlQueryWithAbort(self):
    """test method after getting the source path from the user using abort"""
    with tempfile.TemporaryDirectory() as tmpdir:
      path = os.path.join(tmpdir, 'testfile')
      pathlib.Path(path).touch()

      output_handler = output_handler_file.OutputHandlerFile(
          path, file_handler.FileHandler(), prompt_info='abort', confirm=True,
          confirm_amount_same=2)
      plugin_helper = fake_sqlite_plugin_helper.FakeSQLitePluginHelper()
      controller = sqlite_controller.SQLiteController(output_handler,
                                                      plugin_helper)

      controller._CreateSQLQueryModelWithUserInput = mock.MagicMock(
          return_value=sql_query_model.SQLQueryModel(
              'query', 'name', None, None, True, 0))

      actual = controller.SQLQuery(None, None, True)

      prompt_output_actual = self._ReadFromFile(path)
      prompt_output_expected = (
          'Please write your SQL script for the plugin'
          'Do you want to add another Query?'
          'Please write your SQL script for the plugin [\'abort\' to continue]')

      self.assertEqual(len(actual), 1)
      self.assertEqual(actual[0].query, 'query')
      self.assertEqual(prompt_output_actual, prompt_output_expected)

def testSqlQueryMultiple(self):
    """test method after getting the source path from the user"""
    with tempfile.TemporaryDirectory() as tmpdir:
      path = os.path.join(tmpdir, 'testfile')
      pathlib.Path(path).touch()

      output_handler = output_handler_file.OutputHandlerFile(
          path, file_handler.FileHandler(), confirm=True, confirm_amount_same=2)
      plugin_helper = fake_sqlite_plugin_helper.FakeSQLitePluginHelper()
      controller = sqlite_controller.SQLiteController(output_handler,
                                                      plugin_helper)

      controller._CreateSQLQueryModelWithUserInput = mock.MagicMock(
          return_value=sql_query_data.SQLQueryData(
              data='test', has_error=False, error_message=None))

      actual = controller.SQLQuery(None, None, True)

      prompt_output_expected = (
          'Please write your SQL script for the plugin'
          'Do you want to add another Query?'
          'Please write your SQL script for the plugin [\'abort\' to continue]'
          'Do you want to add another Query?'
          'Please write your SQL script for the plugin [\'abort\' to continue]'
          'Do you want to add another Query?'
      )
      prompt_output_actual = self._ReadFromFile(path)

    self.assertEqual(len(actual), 3)
    self.assertEqual(actual[0].data, 'test')
    self.assertEqual(actual[0].has_error, False)
    self.assertEqual(actual[0].error_message, None)
    self.assertEqual(actual[1].data, 'test')
    self.assertEqual(actual[1].has_error, False)
    self.assertEqual(actual[1].error_message, None)
    self.assertEqual(actual[2].data, 'test')
    self.assertEqual(actual[2].has_error, False)
    self.assertEqual(actual[2].error_message, None)

    self.assertEqual(prompt_output_actual, prompt_output_expected)

def test_call_args_py35():
    m = MagicMock()
    m(1, 2, 3, a=4)
    v = pformat(m.call_args)

    assert v == """\
_Call(
    (1, 2, 3),
    {'a': 4},
)"""

def test_call_args_py36():
    m = MagicMock()
    m(1, 2, 3, a=4)
    v = pformat(m.call_args)

    assert v == """\
_Call(
    _fields=(1, 2, 3),
    {'a': 4},
)"""

def setUp(self):
        self.db_session = MagicMock()
        self.like_mock = MagicMock()
        self.user_id = 1
        self.talk_id = 1
        self.talk = Talk(id=self.talk_id)

def test_set_like(self, like_class_mock):
        like_class_mock.return_value = self.like_mock
        self.talk.is_liked_by = MagicMock(return_value=False)
        self.talk.set_like(self.user_id, self.db_session)
        like_class_mock.assert_called_once_with(user_facebook_id=self.user_id, talk_id=self.talk_id)
        self.db_session.add.assert_called_once_with(self.like_mock)

def test_unset_like(self):
        self.talk.is_liked_by = MagicMock(return_value=True)
        scalar_mock = MagicMock(return_value=self.like_mock)
        self.db_session.query().filter_by().scalar = scalar_mock
        self.talk.unset_like(self.user_id, self.db_session)
        self.db_session.delete.assert_called_once_with(self.like_mock)

def setUp(self):
        self.access_token = 1
        self.sender_id = 'USER_ID'

        server.app.config['ACCESS_TOKEN'] = self.access_token
        self.app = server.app.test_client()
        server.engine = MagicMock()
        server.Session = MagicMock()
        server.db_session = MagicMock()

def test_handle_talk_info_command_gets_called(self, message_handlers_mock):
        message_handlers_mock.handle_talk_info_command = MagicMock()
        known_input = self.generate_postback('info talk 1')
        self.app.post('/', data=json.dumps(known_input), content_type='application/json')
        number_of_calls = message_handlers_mock.handle_talk_info_command.call_count
        self.assertEqual(number_of_calls, 1)

def test_handle_talk_like_command_gets_called(self, message_handlers_mock):
        message_handlers_mock.handle_talk_like_command = MagicMock()
        known_input = self.generate_quick_reply('like talk 1')
        self.app.post('/', data=json.dumps(known_input), content_type='application/json')
        number_of_calls = message_handlers_mock.handle_talk_like_command.call_count
        self.assertEqual(number_of_calls, 1)

def test_handle_no_ask_question_url_postback_gets_called(self, message_handlers_mock):
        message_handlers_mock.handle_no_ask_question_url_postback = MagicMock()
        known_input = self.generate_postback('ask question no url')
        self.app.post('/', data=json.dumps(known_input), content_type='application/json')
        number_of_calls = message_handlers_mock.handle_no_ask_question_url_postback.call_count
        self.assertEqual(number_of_calls, 1)

def test_handle_schedule_command_gets_called(self, message_handlers_mock):
        message_handlers_mock.handle_schedule_command = MagicMock()
        known_input = self.generate_quick_reply('schedule payload')
        self.app.post('/', data=json.dumps(known_input), content_type='application/json')
        number_of_calls = message_handlers_mock.handle_schedule_command.call_count
        self.assertEqual(number_of_calls, 1)

def test_handle_speaker_auth_gets_called(self, message_handlers_mock):
        message_handlers_mock.handle_speaker_auth = MagicMock()
        known_input = self.generate_simple_text_message()
        self.app.post('/', data=json.dumps(known_input), content_type='application/json')
        number_of_calls = message_handlers_mock.handle_speaker_auth.call_count
        self.assertEqual(number_of_calls, 1)

def setUp(self):
        self.access_token = 1
        self.sender_id = 'USER_ID'
        server.app.config['ACCESS_TOKEN'] = self.access_token
        server.engine = MagicMock()
        server.Session = MagicMock()
        server.db_session = MagicMock()

def test_handle_speaker_auth(self, speaker_class_mock, send_authentication_confirmation_mock):
        messaging_event = self.generate_simple_text_message()
        speaker_mock = MagicMock()
        server.db_session.query().filter_by().scalar = MagicMock(return_value=speaker_mock)
        speaker_mock.page_scoped_id = None
        speaker_mock.name = 'asdaf'
        message_handlers.handle_speaker_auth(messaging_event, self.access_token, server.db_session)
        send_authentication_confirmation_mock.assert_called_once_with(
            self.access_token, 
            self.sender_id,
            speaker_mock.name
            )

def create_mockup_talk(self):
        talk_mock = MagicMock(id=1, title=1, speaker_facebook_id=1)
        talk_mock.is_liked_by = MagicMock(return_value=False)
        return talk_mock