go.uber.org/cadence@v1.2.9/internal/common/auth/service_wrapper_test.go (about)

     1  // Copyright (c) 2021 Uber Technologies, Inc.
     2  //
     3  // Permission is hereby granted, free of charge, to any person obtaining a copy
     4  // of this software and associated documentation files (the "Software"), to deal
     5  // in the Software without restriction, including without limitation the rights
     6  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     7  // copies of the Software, and to permit persons to whom the Software is
     8  // furnished to do so, subject to the following conditions:
     9  //
    10  // The above copyright notice and this permission notice shall be included in
    11  // all copies or substantial portions of the Software.
    12  //
    13  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    14  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    15  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    16  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    17  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    18  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    19  // THE SOFTWARE.
    20  
    21  package auth
    22  
    23  import (
    24  	"fmt"
    25  	"testing"
    26  	"time"
    27  
    28  	"github.com/golang/mock/gomock"
    29  	"github.com/stretchr/testify/suite"
    30  	"github.com/uber/tchannel-go/thrift"
    31  
    32  	"go.uber.org/cadence/.gen/go/cadence/workflowservicetest"
    33  	"go.uber.org/cadence/.gen/go/shared"
    34  )
    35  
    36  type (
    37  	serviceWrapperSuite struct {
    38  		suite.Suite
    39  		Service      *workflowservicetest.MockClient
    40  		AuthProvider AuthorizationProvider
    41  		controller   *gomock.Controller
    42  	}
    43  )
    44  
    45  type jwtAuthCorrect struct{}
    46  
    47  func (j *jwtAuthCorrect) GetAuthToken() ([]byte, error) {
    48  	return []byte{}, nil
    49  }
    50  
    51  func newJWTAuthCorrect() AuthorizationProvider {
    52  	return &jwtAuthCorrect{}
    53  }
    54  
    55  type jwtAuthIncorrect struct{}
    56  
    57  func (j *jwtAuthIncorrect) GetAuthToken() ([]byte, error) {
    58  	return []byte{}, fmt.Errorf("error")
    59  }
    60  
    61  func newJWTAuthIncorrect() AuthorizationProvider {
    62  	return &jwtAuthIncorrect{}
    63  }
    64  
    65  func TestServiceWrapperSuite(t *testing.T) {
    66  	suite.Run(t, new(serviceWrapperSuite))
    67  }
    68  
    69  func (s *serviceWrapperSuite) SetupTest() {
    70  	s.controller = gomock.NewController(s.T())
    71  	s.Service = workflowservicetest.NewMockClient(s.controller)
    72  	s.AuthProvider = newJWTAuthCorrect()
    73  }
    74  
    75  func (s *serviceWrapperSuite) TearDownTest() {
    76  	s.controller.Finish()
    77  }
    78  
    79  func (s *serviceWrapperSuite) TestDeprecateDomainValidToken() {
    80  	s.Service.EXPECT().DeprecateDomain(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
    81  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
    82  	ctx, _ := thrift.NewContext(time.Minute)
    83  	err := sw.DeprecateDomain(ctx, &shared.DeprecateDomainRequest{})
    84  	s.NoError(err)
    85  }
    86  
    87  func (s *serviceWrapperSuite) TestDeprecateDomainInvalidToken() {
    88  	s.AuthProvider = newJWTAuthIncorrect()
    89  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
    90  	ctx, _ := thrift.NewContext(time.Minute)
    91  	err := sw.DeprecateDomain(ctx, &shared.DeprecateDomainRequest{})
    92  	s.EqualError(err, "error")
    93  }
    94  
    95  func (s *serviceWrapperSuite) TestListDomainsValidToken() {
    96  	s.Service.EXPECT().ListDomains(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
    97  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
    98  	ctx, _ := thrift.NewContext(time.Minute)
    99  	_, err := sw.ListDomains(ctx, &shared.ListDomainsRequest{})
   100  	s.NoError(err)
   101  }
   102  
   103  func (s *serviceWrapperSuite) TestListDomainsInvalidToken() {
   104  	s.AuthProvider = newJWTAuthIncorrect()
   105  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   106  	ctx, _ := thrift.NewContext(time.Minute)
   107  	_, err := sw.ListDomains(ctx, &shared.ListDomainsRequest{})
   108  	s.EqualError(err, "error")
   109  }
   110  
   111  func (s *serviceWrapperSuite) TestDescribeDomainValidToken() {
   112  	s.Service.EXPECT().DescribeDomain(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   113  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   114  	ctx, _ := thrift.NewContext(time.Minute)
   115  	_, err := sw.DescribeDomain(ctx, &shared.DescribeDomainRequest{})
   116  	s.NoError(err)
   117  }
   118  
   119  func (s *serviceWrapperSuite) TestDescribeDomainInvalidToken() {
   120  	s.AuthProvider = newJWTAuthIncorrect()
   121  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   122  	ctx, _ := thrift.NewContext(time.Minute)
   123  	_, err := sw.DescribeDomain(ctx, &shared.DescribeDomainRequest{})
   124  	s.EqualError(err, "error")
   125  }
   126  
   127  func (s *serviceWrapperSuite) TestDescribeWorkflowExecutionValidToken() {
   128  	s.Service.EXPECT().DescribeWorkflowExecution(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   129  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   130  	ctx, _ := thrift.NewContext(time.Minute)
   131  	_, err := sw.DescribeWorkflowExecution(ctx, &shared.DescribeWorkflowExecutionRequest{})
   132  	s.NoError(err)
   133  }
   134  
   135  func (s *serviceWrapperSuite) TestDescribeWorkflowExecutionInvalidToken() {
   136  	s.AuthProvider = newJWTAuthIncorrect()
   137  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   138  	ctx, _ := thrift.NewContext(time.Minute)
   139  	_, err := sw.DescribeWorkflowExecution(ctx, &shared.DescribeWorkflowExecutionRequest{})
   140  	s.EqualError(err, "error")
   141  }
   142  
   143  func (s *serviceWrapperSuite) TestGetWorkflowExecutionHistoryValidToken() {
   144  	s.Service.EXPECT().GetWorkflowExecutionHistory(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   145  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   146  	ctx, _ := thrift.NewContext(time.Minute)
   147  	_, err := sw.GetWorkflowExecutionHistory(ctx, &shared.GetWorkflowExecutionHistoryRequest{})
   148  	s.NoError(err)
   149  }
   150  
   151  func (s *serviceWrapperSuite) TestGetWorkflowExecutionHistoryInvalidToken() {
   152  	s.AuthProvider = newJWTAuthIncorrect()
   153  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   154  	ctx, _ := thrift.NewContext(time.Minute)
   155  	_, err := sw.GetWorkflowExecutionHistory(ctx, &shared.GetWorkflowExecutionHistoryRequest{})
   156  	s.EqualError(err, "error")
   157  }
   158  
   159  func (s *serviceWrapperSuite) TestListClosedWorkflowExecutionsValidToken() {
   160  	s.Service.EXPECT().ListClosedWorkflowExecutions(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   161  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   162  	ctx, _ := thrift.NewContext(time.Minute)
   163  	_, err := sw.ListClosedWorkflowExecutions(ctx, &shared.ListClosedWorkflowExecutionsRequest{})
   164  	s.NoError(err)
   165  }
   166  
   167  func (s *serviceWrapperSuite) TestListClosedWorkflowExecutionsInvalidToken() {
   168  	s.AuthProvider = newJWTAuthIncorrect()
   169  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   170  	ctx, _ := thrift.NewContext(time.Minute)
   171  	_, err := sw.ListClosedWorkflowExecutions(ctx, &shared.ListClosedWorkflowExecutionsRequest{})
   172  	s.EqualError(err, "error")
   173  }
   174  
   175  func (s *serviceWrapperSuite) TestListOpenWorkflowExecutionsValidToken() {
   176  	s.Service.EXPECT().ListOpenWorkflowExecutions(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   177  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   178  	ctx, _ := thrift.NewContext(time.Minute)
   179  	_, err := sw.ListOpenWorkflowExecutions(ctx, &shared.ListOpenWorkflowExecutionsRequest{})
   180  	s.NoError(err)
   181  }
   182  
   183  func (s *serviceWrapperSuite) TestListOpenWorkflowExecutionsInvalidToken() {
   184  	s.AuthProvider = newJWTAuthIncorrect()
   185  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   186  	ctx, _ := thrift.NewContext(time.Minute)
   187  	_, err := sw.ListOpenWorkflowExecutions(ctx, &shared.ListOpenWorkflowExecutionsRequest{})
   188  	s.EqualError(err, "error")
   189  }
   190  
   191  func (s *serviceWrapperSuite) TestListWorkflowExecutionsValidToken() {
   192  	s.Service.EXPECT().ListWorkflowExecutions(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   193  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   194  	ctx, _ := thrift.NewContext(time.Minute)
   195  	_, err := sw.ListWorkflowExecutions(ctx, &shared.ListWorkflowExecutionsRequest{})
   196  	s.NoError(err)
   197  }
   198  
   199  func (s *serviceWrapperSuite) TestListWorkflowExecutionsInvalidToken() {
   200  	s.AuthProvider = newJWTAuthIncorrect()
   201  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   202  	ctx, _ := thrift.NewContext(time.Minute)
   203  	_, err := sw.ListWorkflowExecutions(ctx, &shared.ListWorkflowExecutionsRequest{})
   204  	s.EqualError(err, "error")
   205  }
   206  
   207  func (s *serviceWrapperSuite) TestListArchivedWorkflowExecutionsValidToken() {
   208  	s.Service.EXPECT().ListArchivedWorkflowExecutions(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   209  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   210  	ctx, _ := thrift.NewContext(time.Minute)
   211  	_, err := sw.ListArchivedWorkflowExecutions(ctx, &shared.ListArchivedWorkflowExecutionsRequest{})
   212  	s.NoError(err)
   213  }
   214  
   215  func (s *serviceWrapperSuite) TestListArchivedWorkflowExecutionsInvalidToken() {
   216  	s.AuthProvider = newJWTAuthIncorrect()
   217  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   218  	ctx, _ := thrift.NewContext(time.Minute)
   219  	_, err := sw.ListArchivedWorkflowExecutions(ctx, &shared.ListArchivedWorkflowExecutionsRequest{})
   220  	s.EqualError(err, "error")
   221  }
   222  
   223  func (s *serviceWrapperSuite) TestScanWorkflowExecutionsValidToken() {
   224  	s.Service.EXPECT().ScanWorkflowExecutions(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   225  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   226  	ctx, _ := thrift.NewContext(time.Minute)
   227  	_, err := sw.ScanWorkflowExecutions(ctx, &shared.ListWorkflowExecutionsRequest{})
   228  	s.NoError(err)
   229  }
   230  
   231  func (s *serviceWrapperSuite) TestScanWorkflowExecutionsInvalidToken() {
   232  	s.AuthProvider = newJWTAuthIncorrect()
   233  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   234  	ctx, _ := thrift.NewContext(time.Minute)
   235  	_, err := sw.ScanWorkflowExecutions(ctx, &shared.ListWorkflowExecutionsRequest{})
   236  	s.EqualError(err, "error")
   237  }
   238  
   239  func (s *serviceWrapperSuite) TestCountWorkflowExecutionsValidToken() {
   240  	s.Service.EXPECT().CountWorkflowExecutions(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   241  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   242  	ctx, _ := thrift.NewContext(time.Minute)
   243  	_, err := sw.CountWorkflowExecutions(ctx, &shared.CountWorkflowExecutionsRequest{})
   244  	s.NoError(err)
   245  }
   246  
   247  func (s *serviceWrapperSuite) TestCountWorkflowExecutionsInvalidToken() {
   248  	s.AuthProvider = newJWTAuthIncorrect()
   249  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   250  	ctx, _ := thrift.NewContext(time.Minute)
   251  	_, err := sw.CountWorkflowExecutions(ctx, &shared.CountWorkflowExecutionsRequest{})
   252  	s.EqualError(err, "error")
   253  }
   254  
   255  func (s *serviceWrapperSuite) TestPollForActivityTaskValidToken() {
   256  	s.Service.EXPECT().PollForActivityTask(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   257  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   258  	ctx, _ := thrift.NewContext(time.Minute)
   259  	_, err := sw.PollForActivityTask(ctx, &shared.PollForActivityTaskRequest{})
   260  	s.NoError(err)
   261  }
   262  
   263  func (s *serviceWrapperSuite) TestPollForActivityTaskInvalidToken() {
   264  	s.AuthProvider = newJWTAuthIncorrect()
   265  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   266  	ctx, _ := thrift.NewContext(time.Minute)
   267  	_, err := sw.PollForActivityTask(ctx, &shared.PollForActivityTaskRequest{})
   268  	s.EqualError(err, "error")
   269  }
   270  
   271  func (s *serviceWrapperSuite) TestPollForDecisionTaskValidToken() {
   272  	s.Service.EXPECT().PollForDecisionTask(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   273  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   274  	ctx, _ := thrift.NewContext(time.Minute)
   275  	_, err := sw.PollForDecisionTask(ctx, &shared.PollForDecisionTaskRequest{})
   276  	s.NoError(err)
   277  }
   278  
   279  func (s *serviceWrapperSuite) TestPollForDecisionTaskInvalidToken() {
   280  	s.AuthProvider = newJWTAuthIncorrect()
   281  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   282  	ctx, _ := thrift.NewContext(time.Minute)
   283  	_, err := sw.PollForDecisionTask(ctx, &shared.PollForDecisionTaskRequest{})
   284  	s.EqualError(err, "error")
   285  }
   286  
   287  func (s *serviceWrapperSuite) TestRecordActivityTaskHeartbeatValidToken() {
   288  	s.Service.EXPECT().RecordActivityTaskHeartbeat(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   289  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   290  	ctx, _ := thrift.NewContext(time.Minute)
   291  	_, err := sw.RecordActivityTaskHeartbeat(ctx, &shared.RecordActivityTaskHeartbeatRequest{})
   292  	s.NoError(err)
   293  }
   294  
   295  func (s *serviceWrapperSuite) TestRecordActivityTaskHeartbeatInvalidToken() {
   296  	s.AuthProvider = newJWTAuthIncorrect()
   297  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   298  	ctx, _ := thrift.NewContext(time.Minute)
   299  	_, err := sw.RecordActivityTaskHeartbeat(ctx, &shared.RecordActivityTaskHeartbeatRequest{})
   300  	s.EqualError(err, "error")
   301  }
   302  
   303  func (s *serviceWrapperSuite) TestRecordActivityTaskHeartbeatByIDValidToken() {
   304  	s.Service.EXPECT().RecordActivityTaskHeartbeatByID(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   305  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   306  	ctx, _ := thrift.NewContext(time.Minute)
   307  	_, err := sw.RecordActivityTaskHeartbeatByID(ctx, &shared.RecordActivityTaskHeartbeatByIDRequest{})
   308  	s.NoError(err)
   309  }
   310  
   311  func (s *serviceWrapperSuite) TestRecordActivityTaskHeartbeatByIDInvalidToken() {
   312  	s.AuthProvider = newJWTAuthIncorrect()
   313  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   314  	ctx, _ := thrift.NewContext(time.Minute)
   315  	_, err := sw.RecordActivityTaskHeartbeatByID(ctx, &shared.RecordActivityTaskHeartbeatByIDRequest{})
   316  	s.EqualError(err, "error")
   317  }
   318  
   319  func (s *serviceWrapperSuite) TestRegisterDomainValidToken() {
   320  	s.Service.EXPECT().RegisterDomain(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   321  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   322  	ctx, _ := thrift.NewContext(time.Minute)
   323  	err := sw.RegisterDomain(ctx, &shared.RegisterDomainRequest{})
   324  	s.NoError(err)
   325  }
   326  
   327  func (s *serviceWrapperSuite) TestRegisterDomainInvalidToken() {
   328  	s.AuthProvider = newJWTAuthIncorrect()
   329  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   330  	ctx, _ := thrift.NewContext(time.Minute)
   331  	err := sw.RegisterDomain(ctx, &shared.RegisterDomainRequest{})
   332  	s.EqualError(err, "error")
   333  }
   334  
   335  func (s *serviceWrapperSuite) TestRequestCancelWorkflowExecutionValidToken() {
   336  	s.Service.EXPECT().RequestCancelWorkflowExecution(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   337  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   338  	ctx, _ := thrift.NewContext(time.Minute)
   339  	err := sw.RequestCancelWorkflowExecution(ctx, &shared.RequestCancelWorkflowExecutionRequest{})
   340  	s.NoError(err)
   341  }
   342  
   343  func (s *serviceWrapperSuite) TestRequestCancelWorkflowExecutionInvalidToken() {
   344  	s.AuthProvider = newJWTAuthIncorrect()
   345  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   346  	ctx, _ := thrift.NewContext(time.Minute)
   347  	err := sw.RequestCancelWorkflowExecution(ctx, &shared.RequestCancelWorkflowExecutionRequest{})
   348  	s.EqualError(err, "error")
   349  }
   350  
   351  func (s *serviceWrapperSuite) TestRespondActivityTaskCanceledValidToken() {
   352  	s.Service.EXPECT().RespondActivityTaskCanceled(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   353  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   354  	ctx, _ := thrift.NewContext(time.Minute)
   355  	err := sw.RespondActivityTaskCanceled(ctx, &shared.RespondActivityTaskCanceledRequest{})
   356  	s.NoError(err)
   357  }
   358  
   359  func (s *serviceWrapperSuite) TestRespondActivityTaskCanceledInvalidToken() {
   360  	s.AuthProvider = newJWTAuthIncorrect()
   361  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   362  	ctx, _ := thrift.NewContext(time.Minute)
   363  	err := sw.RespondActivityTaskCanceled(ctx, &shared.RespondActivityTaskCanceledRequest{})
   364  	s.EqualError(err, "error")
   365  }
   366  
   367  func (s *serviceWrapperSuite) TestRespondActivityTaskCompletedValidToken() {
   368  	s.Service.EXPECT().RespondActivityTaskCompleted(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   369  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   370  	ctx, _ := thrift.NewContext(time.Minute)
   371  	err := sw.RespondActivityTaskCompleted(ctx, &shared.RespondActivityTaskCompletedRequest{})
   372  	s.NoError(err)
   373  }
   374  
   375  func (s *serviceWrapperSuite) TestRespondActivityTaskCompletedInvalidToken() {
   376  	s.AuthProvider = newJWTAuthIncorrect()
   377  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   378  	ctx, _ := thrift.NewContext(time.Minute)
   379  	err := sw.RespondActivityTaskCompleted(ctx, &shared.RespondActivityTaskCompletedRequest{})
   380  	s.EqualError(err, "error")
   381  }
   382  
   383  func (s *serviceWrapperSuite) TestRespondActivityTaskFailedValidToken() {
   384  	s.Service.EXPECT().RespondActivityTaskFailed(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   385  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   386  	ctx, _ := thrift.NewContext(time.Minute)
   387  	err := sw.RespondActivityTaskFailed(ctx, &shared.RespondActivityTaskFailedRequest{})
   388  	s.NoError(err)
   389  }
   390  
   391  func (s *serviceWrapperSuite) TestRespondActivityTaskFailedInvalidToken() {
   392  	s.AuthProvider = newJWTAuthIncorrect()
   393  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   394  	ctx, _ := thrift.NewContext(time.Minute)
   395  	err := sw.RespondActivityTaskFailed(ctx, &shared.RespondActivityTaskFailedRequest{})
   396  	s.EqualError(err, "error")
   397  }
   398  
   399  func (s *serviceWrapperSuite) TestRespondActivityTaskCanceledByIDValidToken() {
   400  	s.Service.EXPECT().RespondActivityTaskCanceledByID(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   401  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   402  	ctx, _ := thrift.NewContext(time.Minute)
   403  	err := sw.RespondActivityTaskCanceledByID(ctx, &shared.RespondActivityTaskCanceledByIDRequest{})
   404  	s.NoError(err)
   405  }
   406  
   407  func (s *serviceWrapperSuite) TestRespondActivityTaskCanceledByIDInvalidToken() {
   408  	s.AuthProvider = newJWTAuthIncorrect()
   409  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   410  	ctx, _ := thrift.NewContext(time.Minute)
   411  	err := sw.RespondActivityTaskCanceledByID(ctx, &shared.RespondActivityTaskCanceledByIDRequest{})
   412  	s.EqualError(err, "error")
   413  }
   414  
   415  func (s *serviceWrapperSuite) TestRespondActivityTaskCompletedByIDValidToken() {
   416  	s.Service.EXPECT().RespondActivityTaskCompletedByID(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   417  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   418  	ctx, _ := thrift.NewContext(time.Minute)
   419  	err := sw.RespondActivityTaskCompletedByID(ctx, &shared.RespondActivityTaskCompletedByIDRequest{})
   420  	s.NoError(err)
   421  }
   422  
   423  func (s *serviceWrapperSuite) TestRespondActivityTaskCompletedByIDInvalidToken() {
   424  	s.AuthProvider = newJWTAuthIncorrect()
   425  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   426  	ctx, _ := thrift.NewContext(time.Minute)
   427  	err := sw.RespondActivityTaskCompletedByID(ctx, &shared.RespondActivityTaskCompletedByIDRequest{})
   428  	s.EqualError(err, "error")
   429  }
   430  
   431  func (s *serviceWrapperSuite) TestRespondActivityTaskFailedByIDValidToken() {
   432  	s.Service.EXPECT().RespondActivityTaskFailedByID(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   433  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   434  	ctx, _ := thrift.NewContext(time.Minute)
   435  	err := sw.RespondActivityTaskFailedByID(ctx, &shared.RespondActivityTaskFailedByIDRequest{})
   436  	s.NoError(err)
   437  }
   438  
   439  func (s *serviceWrapperSuite) TestRespondActivityTaskFailedByIDInvalidToken() {
   440  	s.AuthProvider = newJWTAuthIncorrect()
   441  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   442  	ctx, _ := thrift.NewContext(time.Minute)
   443  	err := sw.RespondActivityTaskFailedByID(ctx, &shared.RespondActivityTaskFailedByIDRequest{})
   444  	s.EqualError(err, "error")
   445  }
   446  
   447  func (s *serviceWrapperSuite) TestRespondDecisionTaskCompletedValidToken() {
   448  	s.Service.EXPECT().RespondDecisionTaskCompleted(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   449  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   450  	ctx, _ := thrift.NewContext(time.Minute)
   451  	_, err := sw.RespondDecisionTaskCompleted(ctx, &shared.RespondDecisionTaskCompletedRequest{})
   452  	s.NoError(err)
   453  }
   454  
   455  func (s *serviceWrapperSuite) TestRespondDecisionTaskCompletedInvalidToken() {
   456  	s.AuthProvider = newJWTAuthIncorrect()
   457  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   458  	ctx, _ := thrift.NewContext(time.Minute)
   459  	_, err := sw.RespondDecisionTaskCompleted(ctx, &shared.RespondDecisionTaskCompletedRequest{})
   460  	s.EqualError(err, "error")
   461  }
   462  
   463  func (s *serviceWrapperSuite) TestRespondDecisionTaskFailedValidToken() {
   464  	s.Service.EXPECT().RespondDecisionTaskFailed(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   465  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   466  	ctx, _ := thrift.NewContext(time.Minute)
   467  	err := sw.RespondDecisionTaskFailed(ctx, &shared.RespondDecisionTaskFailedRequest{})
   468  	s.NoError(err)
   469  }
   470  
   471  func (s *serviceWrapperSuite) TestRespondDecisionTaskFailedInvalidToken() {
   472  	s.AuthProvider = newJWTAuthIncorrect()
   473  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   474  	ctx, _ := thrift.NewContext(time.Minute)
   475  	err := sw.RespondDecisionTaskFailed(ctx, &shared.RespondDecisionTaskFailedRequest{})
   476  	s.EqualError(err, "error")
   477  }
   478  
   479  func (s *serviceWrapperSuite) TestSignalWorkflowExecutionValidToken() {
   480  	s.Service.EXPECT().SignalWorkflowExecution(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   481  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   482  	ctx, _ := thrift.NewContext(time.Minute)
   483  	err := sw.SignalWorkflowExecution(ctx, &shared.SignalWorkflowExecutionRequest{})
   484  	s.NoError(err)
   485  }
   486  
   487  func (s *serviceWrapperSuite) TestSignalWorkflowExecutionInvalidToken() {
   488  	s.AuthProvider = newJWTAuthIncorrect()
   489  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   490  	ctx, _ := thrift.NewContext(time.Minute)
   491  	err := sw.SignalWorkflowExecution(ctx, &shared.SignalWorkflowExecutionRequest{})
   492  	s.EqualError(err, "error")
   493  }
   494  
   495  func (s *serviceWrapperSuite) TestSignalWithStartWorkflowExecutionToken() {
   496  	s.Service.EXPECT().SignalWithStartWorkflowExecution(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   497  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   498  	ctx, _ := thrift.NewContext(time.Minute)
   499  	_, err := sw.SignalWithStartWorkflowExecution(ctx, &shared.SignalWithStartWorkflowExecutionRequest{})
   500  	s.NoError(err)
   501  }
   502  
   503  func (s *serviceWrapperSuite) TestSignalWithStartWorkflowExecutionInvalidToken() {
   504  	s.AuthProvider = newJWTAuthIncorrect()
   505  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   506  	ctx, _ := thrift.NewContext(time.Minute)
   507  	_, err := sw.SignalWithStartWorkflowExecution(ctx, &shared.SignalWithStartWorkflowExecutionRequest{})
   508  	s.EqualError(err, "error")
   509  }
   510  
   511  func (s *serviceWrapperSuite) TestStartWorkflowExecutionToken() {
   512  	s.Service.EXPECT().StartWorkflowExecution(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   513  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   514  	ctx, _ := thrift.NewContext(time.Minute)
   515  	_, err := sw.StartWorkflowExecution(ctx, &shared.StartWorkflowExecutionRequest{})
   516  	s.NoError(err)
   517  }
   518  
   519  func (s *serviceWrapperSuite) TestStartWorkflowExecutionInvalidToken() {
   520  	s.AuthProvider = newJWTAuthIncorrect()
   521  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   522  	ctx, _ := thrift.NewContext(time.Minute)
   523  	_, err := sw.StartWorkflowExecution(ctx, &shared.StartWorkflowExecutionRequest{})
   524  	s.EqualError(err, "error")
   525  }
   526  
   527  func (s *serviceWrapperSuite) TestTerminateWorkflowExecutionToken() {
   528  	s.Service.EXPECT().TerminateWorkflowExecution(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   529  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   530  	ctx, _ := thrift.NewContext(time.Minute)
   531  	err := sw.TerminateWorkflowExecution(ctx, &shared.TerminateWorkflowExecutionRequest{})
   532  	s.NoError(err)
   533  }
   534  
   535  func (s *serviceWrapperSuite) TestTerminateWorkflowExecutionInvalidToken() {
   536  	s.AuthProvider = newJWTAuthIncorrect()
   537  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   538  	ctx, _ := thrift.NewContext(time.Minute)
   539  	err := sw.TerminateWorkflowExecution(ctx, &shared.TerminateWorkflowExecutionRequest{})
   540  	s.EqualError(err, "error")
   541  }
   542  
   543  func (s *serviceWrapperSuite) TestResetWorkflowExecutionValidToken() {
   544  	s.Service.EXPECT().ResetWorkflowExecution(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   545  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   546  	ctx, _ := thrift.NewContext(time.Minute)
   547  	_, err := sw.ResetWorkflowExecution(ctx, &shared.ResetWorkflowExecutionRequest{})
   548  	s.NoError(err)
   549  }
   550  
   551  func (s *serviceWrapperSuite) TestResetWorkflowExecutionInvalidToken() {
   552  	s.AuthProvider = newJWTAuthIncorrect()
   553  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   554  	ctx, _ := thrift.NewContext(time.Minute)
   555  	_, err := sw.ResetWorkflowExecution(ctx, &shared.ResetWorkflowExecutionRequest{})
   556  	s.EqualError(err, "error")
   557  }
   558  
   559  func (s *serviceWrapperSuite) TestUpdateDomainValidToken() {
   560  	s.Service.EXPECT().UpdateDomain(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   561  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   562  	ctx, _ := thrift.NewContext(time.Minute)
   563  	_, err := sw.UpdateDomain(ctx, &shared.UpdateDomainRequest{})
   564  	s.NoError(err)
   565  }
   566  
   567  func (s *serviceWrapperSuite) TestUpdateDomainInvalidToken() {
   568  	s.AuthProvider = newJWTAuthIncorrect()
   569  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   570  	ctx, _ := thrift.NewContext(time.Minute)
   571  	_, err := sw.UpdateDomain(ctx, &shared.UpdateDomainRequest{})
   572  	s.EqualError(err, "error")
   573  }
   574  
   575  func (s *serviceWrapperSuite) TestQueryWorkflowValidToken() {
   576  	s.Service.EXPECT().QueryWorkflow(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   577  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   578  	ctx, _ := thrift.NewContext(time.Minute)
   579  	_, err := sw.QueryWorkflow(ctx, &shared.QueryWorkflowRequest{})
   580  	s.NoError(err)
   581  }
   582  
   583  func (s *serviceWrapperSuite) TestQueryWorkflowInvalidToken() {
   584  	s.AuthProvider = newJWTAuthIncorrect()
   585  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   586  	ctx, _ := thrift.NewContext(time.Minute)
   587  	_, err := sw.QueryWorkflow(ctx, &shared.QueryWorkflowRequest{})
   588  	s.EqualError(err, "error")
   589  }
   590  
   591  func (s *serviceWrapperSuite) TestResetStickyTaskListValidToken() {
   592  	s.Service.EXPECT().ResetStickyTaskList(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   593  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   594  	ctx, _ := thrift.NewContext(time.Minute)
   595  	_, err := sw.ResetStickyTaskList(ctx, &shared.ResetStickyTaskListRequest{})
   596  	s.NoError(err)
   597  }
   598  
   599  func (s *serviceWrapperSuite) TestResetStickyTaskListInvalidToken() {
   600  	s.AuthProvider = newJWTAuthIncorrect()
   601  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   602  	ctx, _ := thrift.NewContext(time.Minute)
   603  	_, err := sw.ResetStickyTaskList(ctx, &shared.ResetStickyTaskListRequest{})
   604  	s.EqualError(err, "error")
   605  }
   606  
   607  func (s *serviceWrapperSuite) TestDescribeTaskListValidToken() {
   608  	s.Service.EXPECT().DescribeTaskList(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   609  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   610  	ctx, _ := thrift.NewContext(time.Minute)
   611  	_, err := sw.DescribeTaskList(ctx, &shared.DescribeTaskListRequest{})
   612  	s.NoError(err)
   613  }
   614  
   615  func (s *serviceWrapperSuite) TestDescribeTaskListInvalidToken() {
   616  	s.AuthProvider = newJWTAuthIncorrect()
   617  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   618  	ctx, _ := thrift.NewContext(time.Minute)
   619  	_, err := sw.DescribeTaskList(ctx, &shared.DescribeTaskListRequest{})
   620  	s.EqualError(err, "error")
   621  }
   622  
   623  func (s *serviceWrapperSuite) TestRespondQueryTaskCompletedValidToken() {
   624  	s.Service.EXPECT().RespondQueryTaskCompleted(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   625  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   626  	ctx, _ := thrift.NewContext(time.Minute)
   627  	err := sw.RespondQueryTaskCompleted(ctx, &shared.RespondQueryTaskCompletedRequest{})
   628  	s.NoError(err)
   629  }
   630  
   631  func (s *serviceWrapperSuite) TestRespondQueryTaskCompletedInvalidToken() {
   632  	s.AuthProvider = newJWTAuthIncorrect()
   633  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   634  	ctx, _ := thrift.NewContext(time.Minute)
   635  	err := sw.RespondQueryTaskCompleted(ctx, &shared.RespondQueryTaskCompletedRequest{})
   636  	s.EqualError(err, "error")
   637  }
   638  
   639  func (s *serviceWrapperSuite) TestGetSearchAttributesValidToken() {
   640  	s.Service.EXPECT().GetSearchAttributes(gomock.Any(), gomock.Any()).Times(1)
   641  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   642  	ctx, _ := thrift.NewContext(time.Minute)
   643  	_, err := sw.GetSearchAttributes(ctx)
   644  	s.NoError(err)
   645  }
   646  
   647  func (s *serviceWrapperSuite) TestGetSearchAttributesInvalidToken() {
   648  	s.AuthProvider = newJWTAuthIncorrect()
   649  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   650  	ctx, _ := thrift.NewContext(time.Minute)
   651  	_, err := sw.GetSearchAttributes(ctx)
   652  	s.EqualError(err, "error")
   653  }
   654  
   655  func (s *serviceWrapperSuite) TestListTaskListPartitionsValidToken() {
   656  	s.Service.EXPECT().ListTaskListPartitions(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   657  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   658  	ctx, _ := thrift.NewContext(time.Minute)
   659  	_, err := sw.ListTaskListPartitions(ctx, &shared.ListTaskListPartitionsRequest{})
   660  	s.NoError(err)
   661  }
   662  
   663  func (s *serviceWrapperSuite) TestListTaskListPartitionsInvalidToken() {
   664  	s.AuthProvider = newJWTAuthIncorrect()
   665  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   666  	ctx, _ := thrift.NewContext(time.Minute)
   667  	_, err := sw.ListTaskListPartitions(ctx, &shared.ListTaskListPartitionsRequest{})
   668  	s.EqualError(err, "error")
   669  }
   670  
   671  func (s *serviceWrapperSuite) TestGetClusterInfoValidToken() {
   672  	s.Service.EXPECT().GetClusterInfo(gomock.Any(), gomock.Any()).Times(1)
   673  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   674  	ctx, _ := thrift.NewContext(time.Minute)
   675  	_, err := sw.GetClusterInfo(ctx)
   676  	s.NoError(err)
   677  }
   678  
   679  func (s *serviceWrapperSuite) TestGetClusterInfoInvalidToken() {
   680  	s.AuthProvider = newJWTAuthIncorrect()
   681  	sw := NewWorkflowServiceWrapper(s.Service, s.AuthProvider)
   682  	ctx, _ := thrift.NewContext(time.Minute)
   683  	_, err := sw.GetClusterInfo(ctx)
   684  	s.EqualError(err, "error")
   685  }