github.com/kaleido-io/firefly@v0.0.0-20210622132723-8b4b6aacb971/internal/broadcast/syshandler_datatype_test.go (about)

     1  // Copyright © 2021 Kaleido, Inc.
     2  //
     3  // SPDX-License-Identifier: Apache-2.0
     4  //
     5  // Licensed under the Apache License, Version 2.0 (the "License");
     6  // you may not use this file except in compliance with the License.
     7  // You may obtain a copy of the License at
     8  //
     9  //     http://www.apache.org/licenses/LICENSE-2.0
    10  //
    11  // Unless required by applicable law or agreed to in writing, software
    12  // distributed under the License is distributed on an "AS IS" BASIS,
    13  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  // See the License for the specific language governing permissions and
    15  // limitations under the License.
    16  
    17  package broadcast
    18  
    19  import (
    20  	"context"
    21  	"encoding/json"
    22  	"fmt"
    23  	"testing"
    24  
    25  	"github.com/kaleido-io/firefly/mocks/databasemocks"
    26  	"github.com/kaleido-io/firefly/mocks/datamocks"
    27  	"github.com/kaleido-io/firefly/pkg/fftypes"
    28  	"github.com/stretchr/testify/assert"
    29  	"github.com/stretchr/testify/mock"
    30  )
    31  
    32  func TestHandleSystemBroadcastDatatypeOk(t *testing.T) {
    33  	bm, cancel := newTestBroadcast(t)
    34  	defer cancel()
    35  
    36  	dt := &fftypes.Datatype{
    37  		ID:        fftypes.NewUUID(),
    38  		Validator: fftypes.ValidatorTypeJSON,
    39  		Namespace: "ns1",
    40  		Name:      "name1",
    41  		Version:   "ver1",
    42  		Value:     fftypes.Byteable(`{}`),
    43  	}
    44  	dt.Hash = dt.Value.Hash()
    45  	b, err := json.Marshal(&dt)
    46  	assert.NoError(t, err)
    47  	data := &fftypes.Data{
    48  		Value: fftypes.Byteable(b),
    49  	}
    50  
    51  	mdm := bm.data.(*datamocks.Manager)
    52  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(nil)
    53  	mbi := bm.database.(*databasemocks.Plugin)
    54  	mbi.On("GetDatatypeByName", mock.Anything, "ns1", "name1", "ver1").Return(nil, nil)
    55  	mbi.On("UpsertDatatype", mock.Anything, mock.Anything, false).Return(nil)
    56  	mbi.On("UpsertEvent", mock.Anything, mock.Anything, false).Return(nil)
    57  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
    58  		Header: fftypes.MessageHeader{
    59  			Tag: string(fftypes.SystemTagDefineDatatype),
    60  		},
    61  	}, []*fftypes.Data{data})
    62  	assert.True(t, valid)
    63  	assert.NoError(t, err)
    64  
    65  	mdm.AssertExpectations(t)
    66  	mbi.AssertExpectations(t)
    67  }
    68  
    69  func TestHandleSystemBroadcastDatatypeEventFail(t *testing.T) {
    70  	bm, cancel := newTestBroadcast(t)
    71  	defer cancel()
    72  
    73  	dt := &fftypes.Datatype{
    74  		ID:        fftypes.NewUUID(),
    75  		Validator: fftypes.ValidatorTypeJSON,
    76  		Namespace: "ns1",
    77  		Name:      "name1",
    78  		Version:   "ver1",
    79  		Value:     fftypes.Byteable(`{}`),
    80  	}
    81  	dt.Hash = dt.Value.Hash()
    82  	b, err := json.Marshal(&dt)
    83  	assert.NoError(t, err)
    84  	data := &fftypes.Data{
    85  		Value: fftypes.Byteable(b),
    86  	}
    87  
    88  	mdm := bm.data.(*datamocks.Manager)
    89  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(nil)
    90  	mbi := bm.database.(*databasemocks.Plugin)
    91  	mbi.On("GetDatatypeByName", mock.Anything, "ns1", "name1", "ver1").Return(nil, nil)
    92  	mbi.On("UpsertDatatype", mock.Anything, mock.Anything, false).Return(nil)
    93  	mbi.On("UpsertEvent", mock.Anything, mock.Anything, false).Return(fmt.Errorf("pop"))
    94  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
    95  		Header: fftypes.MessageHeader{
    96  			Tag: string(fftypes.SystemTagDefineDatatype),
    97  		},
    98  	}, []*fftypes.Data{data})
    99  	assert.False(t, valid)
   100  	assert.EqualError(t, err, "pop")
   101  
   102  	mdm.AssertExpectations(t)
   103  	mbi.AssertExpectations(t)
   104  }
   105  
   106  func TestHandleSystemBroadcastDatatypeMissingID(t *testing.T) {
   107  	bm, cancel := newTestBroadcast(t)
   108  	defer cancel()
   109  
   110  	dt := &fftypes.Datatype{
   111  		Validator: fftypes.ValidatorTypeJSON,
   112  		Namespace: "ns1",
   113  		Name:      "name1",
   114  		Version:   "ver1",
   115  		Value:     fftypes.Byteable(`{}`),
   116  	}
   117  	dt.Hash = dt.Value.Hash()
   118  	b, err := json.Marshal(&dt)
   119  	assert.NoError(t, err)
   120  	data := &fftypes.Data{
   121  		Value: fftypes.Byteable(b),
   122  	}
   123  
   124  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   125  		Header: fftypes.MessageHeader{
   126  			Tag: string(fftypes.SystemTagDefineDatatype),
   127  		},
   128  	}, []*fftypes.Data{data})
   129  	assert.False(t, valid)
   130  	assert.NoError(t, err)
   131  }
   132  
   133  func TestHandleSystemBroadcastBadSchema(t *testing.T) {
   134  	bm, cancel := newTestBroadcast(t)
   135  	defer cancel()
   136  
   137  	dt := &fftypes.Datatype{
   138  		ID:        fftypes.NewUUID(),
   139  		Validator: fftypes.ValidatorTypeJSON,
   140  		Namespace: "ns1",
   141  		Name:      "name1",
   142  		Version:   "ver1",
   143  		Value:     fftypes.Byteable(`{}`),
   144  	}
   145  	dt.Hash = dt.Value.Hash()
   146  	b, err := json.Marshal(&dt)
   147  	assert.NoError(t, err)
   148  	data := &fftypes.Data{
   149  		Value: fftypes.Byteable(b),
   150  	}
   151  
   152  	mdm := bm.data.(*datamocks.Manager)
   153  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(fmt.Errorf("pop"))
   154  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   155  		Header: fftypes.MessageHeader{
   156  			Tag: string(fftypes.SystemTagDefineDatatype),
   157  		},
   158  	}, []*fftypes.Data{data})
   159  	assert.False(t, valid)
   160  	assert.NoError(t, err)
   161  
   162  	mdm.AssertExpectations(t)
   163  }
   164  
   165  func TestHandleSystemBroadcastMissingData(t *testing.T) {
   166  	bm, cancel := newTestBroadcast(t)
   167  	defer cancel()
   168  
   169  	dt := &fftypes.Datatype{
   170  		ID:        fftypes.NewUUID(),
   171  		Validator: fftypes.ValidatorTypeJSON,
   172  		Namespace: "ns1",
   173  		Name:      "name1",
   174  		Version:   "ver1",
   175  		Value:     fftypes.Byteable(`{}`),
   176  	}
   177  	dt.Hash = dt.Value.Hash()
   178  
   179  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   180  		Header: fftypes.MessageHeader{
   181  			Tag: string(fftypes.SystemTagDefineDatatype),
   182  		},
   183  	}, []*fftypes.Data{})
   184  	assert.False(t, valid)
   185  	assert.NoError(t, err)
   186  }
   187  
   188  func TestHandleSystemBroadcastDatatypeLookupFail(t *testing.T) {
   189  	bm, cancel := newTestBroadcast(t)
   190  	defer cancel()
   191  
   192  	dt := &fftypes.Datatype{
   193  		ID:        fftypes.NewUUID(),
   194  		Validator: fftypes.ValidatorTypeJSON,
   195  		Namespace: "ns1",
   196  		Name:      "name1",
   197  		Version:   "ver1",
   198  		Value:     fftypes.Byteable(`{}`),
   199  	}
   200  	dt.Hash = dt.Value.Hash()
   201  	b, err := json.Marshal(&dt)
   202  	assert.NoError(t, err)
   203  	data := &fftypes.Data{
   204  		Value: fftypes.Byteable(b),
   205  	}
   206  
   207  	mdm := bm.data.(*datamocks.Manager)
   208  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(nil)
   209  	mbi := bm.database.(*databasemocks.Plugin)
   210  	mbi.On("GetDatatypeByName", mock.Anything, "ns1", "name1", "ver1").Return(nil, fmt.Errorf("pop"))
   211  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   212  		Header: fftypes.MessageHeader{
   213  			Namespace: fftypes.SystemNamespace,
   214  			Tag:       string(fftypes.SystemTagDefineDatatype),
   215  		},
   216  	}, []*fftypes.Data{data})
   217  	assert.False(t, valid)
   218  	assert.EqualError(t, err, "pop")
   219  
   220  	mdm.AssertExpectations(t)
   221  	mbi.AssertExpectations(t)
   222  }
   223  
   224  func TestHandleSystemBroadcastUpsertFail(t *testing.T) {
   225  	bm, cancel := newTestBroadcast(t)
   226  	defer cancel()
   227  
   228  	dt := &fftypes.Datatype{
   229  		ID:        fftypes.NewUUID(),
   230  		Validator: fftypes.ValidatorTypeJSON,
   231  		Namespace: "ns1",
   232  		Name:      "name1",
   233  		Version:   "ver1",
   234  		Value:     fftypes.Byteable(`{}`),
   235  	}
   236  	dt.Hash = dt.Value.Hash()
   237  	b, err := json.Marshal(&dt)
   238  	assert.NoError(t, err)
   239  	data := &fftypes.Data{
   240  		Value: fftypes.Byteable(b),
   241  	}
   242  
   243  	mdm := bm.data.(*datamocks.Manager)
   244  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(nil)
   245  	mbi := bm.database.(*databasemocks.Plugin)
   246  	mbi.On("GetDatatypeByName", mock.Anything, "ns1", "name1", "ver1").Return(nil, nil)
   247  	mbi.On("UpsertDatatype", mock.Anything, mock.Anything, false).Return(fmt.Errorf("pop"))
   248  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   249  		Header: fftypes.MessageHeader{
   250  			Tag: string(fftypes.SystemTagDefineDatatype),
   251  		},
   252  	}, []*fftypes.Data{data})
   253  	assert.False(t, valid)
   254  	assert.EqualError(t, err, "pop")
   255  
   256  	mdm.AssertExpectations(t)
   257  	mbi.AssertExpectations(t)
   258  }
   259  
   260  func TestHandleSystemBroadcastDatatypeDuplicate(t *testing.T) {
   261  	bm, cancel := newTestBroadcast(t)
   262  	defer cancel()
   263  
   264  	dt := &fftypes.Datatype{
   265  		ID:        fftypes.NewUUID(),
   266  		Validator: fftypes.ValidatorTypeJSON,
   267  		Namespace: "ns1",
   268  		Name:      "name1",
   269  		Version:   "ver1",
   270  		Value:     fftypes.Byteable(`{}`),
   271  	}
   272  	dt.Hash = dt.Value.Hash()
   273  	b, err := json.Marshal(&dt)
   274  	assert.NoError(t, err)
   275  	data := &fftypes.Data{
   276  		Value: fftypes.Byteable(b),
   277  	}
   278  
   279  	mdm := bm.data.(*datamocks.Manager)
   280  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(nil)
   281  	mbi := bm.database.(*databasemocks.Plugin)
   282  	mbi.On("GetDatatypeByName", mock.Anything, "ns1", "name1", "ver1").Return(dt, nil)
   283  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   284  		Header: fftypes.MessageHeader{
   285  			Tag: string(fftypes.SystemTagDefineDatatype),
   286  		},
   287  	}, []*fftypes.Data{data})
   288  	assert.False(t, valid)
   289  	assert.NoError(t, err)
   290  
   291  	mdm.AssertExpectations(t)
   292  	mbi.AssertExpectations(t)
   293  }