text: # -*- coding: utf-8 -*-
  
  # Import Python libs
  from __future__ import absolute_import
  
  # Import Salt libs
  import salt.config
  import salt.daemons.masterapi as masterapi
  
  # Import Salt Testing Libs
  from tests.support.unit import TestCase
  from tests.support.mock import (
      patch,
      MagicMock,
  )
  
  
  class LocalFuncsTestCase(TestCase):
      '''
      TestCase for salt.daemons.masterapi.LocalFuncs class
      '''
  
      def setUp(self):
          opts = salt.config.master_config(None)
          self.local_funcs = masterapi.LocalFuncs(opts, 'test-key')
  
      def test_runner_token_not_authenticated(self):
          '''
          Asserts that a TokenAuthenticationError is returned when the token can't authenticate.
          '''
          mock_ret = {u'error': {u'name': u'TokenAuthenticationError',
                                 u'message': u'Authentication failure of type "token" occurred.'}}
          ret = self.local_funcs.runner({u'token': u'asdfasdfasdfasdf'})
          self.assertDictEqual(mock_ret, ret)
  
      def test_runner_token_authorization_error(self):
          '''
          Asserts that a TokenAuthenticationError is returned when the token authenticates, but is
          not authorized.
          '''
          token = u'asdfasdfasdfasdf'
          load = {u'token': token, u'fun': u'test.arg', u'kwarg': {}}
          mock_token = {u'token': token, u'eauth': u'foo', u'name': u'test'}
          mock_ret = {u'error': {u'name': u'TokenAuthenticationError',
                                 u'message': u'Authentication failure of type "token" occurred '
                                             u'for user test.'}}
  
          with patch('salt.auth.LoadAuth.authenticate_token', MagicMock(return_value=mock_token)), \
               patch('salt.auth.LoadAuth.get_auth_list', MagicMock(return_value=[])):
              ret = self.local_funcs.runner(load)
  
          self.assertDictEqual(mock_ret, ret)
  
      def test_runner_token_salt_invocation_error(self):
          '''
          Asserts that a SaltInvocationError is returned when the token authenticates, but the
          command is malformed.
          '''
          token = u'asdfasdfasdfasdf'
          load = {u'token': token, u'fun': u'badtestarg', u'kwarg': {}}
          mock_token = {u'token': token, u'eauth': u'foo', u'name': u'test'}
          mock_ret = {u'error': {u'name': u'SaltInvocationError',
                                 u'message': u'A command invocation error occurred: Check syntax.'}}
  
          with patch('salt.auth.LoadAuth.authenticate_token', MagicMock(return_value=mock_token)), \
               patch('salt.auth.LoadAuth.get_auth_list', MagicMock(return_value=['testing'])):
              ret = self.local_funcs.runner(load)
  
          self.assertDictEqual(mock_ret, ret)
  
      def test_runner_eauth_not_authenticated(self):
          '''
          Asserts that an EauthAuthenticationError is returned when the user can't authenticate.
          '''
          mock_ret = {u'error': {u'name': u'EauthAuthenticationError',
                                 u'message': u'Authentication failure of type "eauth" occurred for '
                                             u'user UNKNOWN.'}}
          ret = self.local_funcs.runner({u'eauth': u'foo'})
          self.assertDictEqual(mock_ret, ret)
  
      def test_runner_eauth_authorization_error(self):
          '''
          Asserts that an EauthAuthenticationError is returned when the user authenticates, but is
          not authorized.
          '''
          load = {u'eauth': u'foo', u'username': u'test', u'fun': u'test.arg', u'kwarg': {}}
          mock_ret = {u'error': {u'name': u'EauthAuthenticationError',
                                 u'message': u'Authentication failure of type "eauth" occurred for '
                                             u'user test.'}}
          with patch('salt.auth.LoadAuth.authenticate_eauth', MagicMock(return_value=True)), \
               patch('salt.auth.LoadAuth.get_auth_list', MagicMock(return_value=[])):
              ret = self.local_funcs.runner(load)
  
          self.assertDictEqual(mock_ret, ret)
  
      def test_runner_eauth_salt_invocation_error(self):
          '''
          Asserts that an EauthAuthenticationError is returned when the user authenticates, but the
          command is malformed.
          '''
          load = {u'eauth': u'foo', u'username': u'test', u'fun': u'bad.test.arg.func', u'kwarg': {}}
          mock_ret = {u'error': {u'name': u'SaltInvocationError',
                                 u'message': u'A command invocation error occurred: Check syntax.'}}
          with patch('salt.auth.LoadAuth.authenticate_eauth', MagicMock(return_value=True)), \
               patch('salt.auth.LoadAuth.get_auth_list', MagicMock(return_value=['testing'])):
              ret = self.local_funcs.runner(load)
  
          self.assertDictEqual(mock_ret, ret)
  
      def test_wheel_token_not_authenticated(self):
          '''
          Asserts that a TokenAuthenticationError is returned when the token can't authenticate.
          '''
          mock_ret = {u'error': {u'name': u'TokenAuthenticationError',
                                 u'message': u'Authentication failure of type "token" occurred.'}}
          ret = self.local_funcs.wheel({u'token': u'asdfasdfasdfasdf'})
          self.assertDictEqual(mock_ret, ret)
  
      def test_wheel_token_authorization_error(self):
          '''
          Asserts that a TokenAuthenticationError is returned when the token authenticates, but is
          not authorized.
          '''
          token = u'asdfasdfasdfasdf'
          load = {u'token': token, u'fun': u'test.arg', u'kwarg': {}}
          mock_token = {u'token': token, u'eauth': u'foo', u'name': u'test'}
          mock_ret = {u'error': {u'name': u'TokenAuthenticationError',
                                 u'message': u'Authentication failure of type "token" occurred '
                                             u'for user test.'}}
  
          with patch('salt.auth.LoadAuth.authenticate_token', MagicMock(return_value=mock_token)), \
               patch('salt.auth.LoadAuth.get_auth_list', MagicMock(return_value=[])):
              ret = self.local_funcs.wheel(load)
  
          self.assertDictEqual(mock_ret, ret)
  
      def test_wheel_token_salt_invocation_error(self):
          '''
          Asserts that a SaltInvocationError is returned when the token authenticates, but the
          command is malformed.
          '''
          token = u'asdfasdfasdfasdf'
          load = {u'token': token, u'fun': u'badtestarg', u'kwarg': {}}
          mock_token = {u'token': token, u'eauth': u'foo', u'name': u'test'}
          mock_ret = {u'error': {u'name': u'SaltInvocationError',
                                 u'message': u'A command invocation error occurred: Check syntax.'}}
  
          with patch('salt.auth.LoadAuth.authenticate_token', MagicMock(return_value=mock_token)), \
               patch('salt.auth.LoadAuth.get_auth_list', MagicMock(return_value=['testing'])):
              ret = self.local_funcs.wheel(load)
  
          self.assertDictEqual(mock_ret, ret)
  
      def test_wheel_eauth_not_authenticated(self):
          '''
          Asserts that an EauthAuthenticationError is returned when the user can't authenticate.
          '''
          mock_ret = {u'error': {u'name': u'EauthAuthenticationError',
                                 u'message': u'Authentication failure of type "eauth" occurred for '
                                             u'user UNKNOWN.'}}
          ret = self.local_funcs.wheel({u'eauth': u'foo'})
          self.assertDictEqual(mock_ret, ret)
  
      def test_wheel_eauth_authorization_error(self):
          '''
          Asserts that an EauthAuthenticationError is returned when the user authenticates, but is
          not authorized.
          '''
          load = {u'eauth': u'foo', u'username': u'test', u'fun': u'test.arg', u'kwarg': {}}
          mock_ret = {u'error': {u'name': u'EauthAuthenticationError',
                                 u'message': u'Authentication failure of type "eauth" occurred for '
                                             u'user test.'}}
          with patch('salt.auth.LoadAuth.authenticate_eauth', MagicMock(return_value=True)), \
               patch('salt.auth.LoadAuth.get_auth_list', MagicMock(return_value=[])):
              ret = self.local_funcs.wheel(load)
  
          self.assertDictEqual(mock_ret, ret)
  
      def test_wheel_eauth_salt_invocation_error(self):
          '''
          Asserts that an EauthAuthenticationError is returned when the user authenticates, but the
          command is malformed.
          '''
          load = {u'eauth': u'foo', u'username': u'test', u'fun': u'bad.test.arg.func', u'kwarg': {}}
          mock_ret = {u'error': {u'name': u'SaltInvocationError',
                                 u'message': u'A command invocation error occurred: Check syntax.'}}
          with patch('salt.auth.LoadAuth.authenticate_eauth', MagicMock(return_value=True)), \
               patch('salt.auth.LoadAuth.get_auth_list', MagicMock(return_value=['testing'])):
              ret = self.local_funcs.wheel(load)
  
          self.assertDictEqual(mock_ret, ret)
  
      def test_wheel_user_not_authenticated(self):
          '''
          Asserts that an UserAuthenticationError is returned when the user can't authenticate.
          '''
          mock_ret = {u'error': {u'name': u'UserAuthenticationError',
                                 u'message': u'Authentication failure of type "user" occurred for '
                                             u'user UNKNOWN.'}}
          ret = self.local_funcs.wheel({})
          self.assertDictEqual(mock_ret, ret)
  