github.com/kaleido-io/firefly@v0.0.0-20210622132723-8b4b6aacb971/internal/broadcast/syshandler_namespace_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/pkg/fftypes"
    27  	"github.com/stretchr/testify/assert"
    28  	"github.com/stretchr/testify/mock"
    29  )
    30  
    31  func TestHandleSystemBroadcastNSOk(t *testing.T) {
    32  	bm, cancel := newTestBroadcast(t)
    33  	defer cancel()
    34  
    35  	ns := &fftypes.Namespace{
    36  		ID:   fftypes.NewUUID(),
    37  		Name: "ns1",
    38  	}
    39  	b, err := json.Marshal(&ns)
    40  	assert.NoError(t, err)
    41  	data := &fftypes.Data{
    42  		Value: fftypes.Byteable(b),
    43  	}
    44  
    45  	mdi := bm.database.(*databasemocks.Plugin)
    46  	mdi.On("GetNamespace", mock.Anything, "ns1").Return(nil, nil)
    47  	mdi.On("UpsertNamespace", mock.Anything, mock.Anything, false).Return(nil)
    48  	mdi.On("UpsertEvent", mock.Anything, mock.Anything, false).Return(nil)
    49  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
    50  		Header: fftypes.MessageHeader{
    51  			Tag: string(fftypes.SystemTagDefineNamespace),
    52  		},
    53  	}, []*fftypes.Data{data})
    54  	assert.True(t, valid)
    55  	assert.NoError(t, err)
    56  
    57  	mdi.AssertExpectations(t)
    58  }
    59  
    60  func TestHandleSystemBroadcastNSEventFail(t *testing.T) {
    61  	bm, cancel := newTestBroadcast(t)
    62  	defer cancel()
    63  
    64  	ns := &fftypes.Namespace{
    65  		ID:   fftypes.NewUUID(),
    66  		Name: "ns1",
    67  	}
    68  	b, err := json.Marshal(&ns)
    69  	assert.NoError(t, err)
    70  	data := &fftypes.Data{
    71  		Value: fftypes.Byteable(b),
    72  	}
    73  
    74  	mdi := bm.database.(*databasemocks.Plugin)
    75  	mdi.On("GetNamespace", mock.Anything, "ns1").Return(nil, nil)
    76  	mdi.On("UpsertNamespace", mock.Anything, mock.Anything, false).Return(nil)
    77  	mdi.On("UpsertEvent", mock.Anything, mock.Anything, false).Return(fmt.Errorf("pop"))
    78  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
    79  		Header: fftypes.MessageHeader{
    80  			Tag: string(fftypes.SystemTagDefineNamespace),
    81  		},
    82  	}, []*fftypes.Data{data})
    83  	assert.False(t, valid)
    84  	assert.EqualError(t, err, "pop")
    85  
    86  	mdi.AssertExpectations(t)
    87  }
    88  
    89  func TestHandleSystemBroadcastNSUpsertFail(t *testing.T) {
    90  	bm, cancel := newTestBroadcast(t)
    91  	defer cancel()
    92  
    93  	ns := &fftypes.Namespace{
    94  		ID:   fftypes.NewUUID(),
    95  		Name: "ns1",
    96  	}
    97  	b, err := json.Marshal(&ns)
    98  	assert.NoError(t, err)
    99  	data := &fftypes.Data{
   100  		Value: fftypes.Byteable(b),
   101  	}
   102  
   103  	mdi := bm.database.(*databasemocks.Plugin)
   104  	mdi.On("GetNamespace", mock.Anything, "ns1").Return(nil, nil)
   105  	mdi.On("UpsertNamespace", mock.Anything, mock.Anything, false).Return(fmt.Errorf("pop"))
   106  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   107  		Header: fftypes.MessageHeader{
   108  			Tag: string(fftypes.SystemTagDefineNamespace),
   109  		},
   110  	}, []*fftypes.Data{data})
   111  	assert.False(t, valid)
   112  	assert.EqualError(t, err, "pop")
   113  
   114  	mdi.AssertExpectations(t)
   115  }
   116  
   117  func TestHandleSystemBroadcastNSMissingData(t *testing.T) {
   118  	bm, cancel := newTestBroadcast(t)
   119  	defer cancel()
   120  
   121  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   122  		Header: fftypes.MessageHeader{
   123  			Tag: string(fftypes.SystemTagDefineNamespace),
   124  		},
   125  	}, []*fftypes.Data{})
   126  	assert.False(t, valid)
   127  	assert.NoError(t, err)
   128  }
   129  
   130  func TestHandleSystemBroadcastNSBadID(t *testing.T) {
   131  	bm, cancel := newTestBroadcast(t)
   132  	defer cancel()
   133  
   134  	ns := &fftypes.Namespace{}
   135  	b, err := json.Marshal(&ns)
   136  	assert.NoError(t, err)
   137  	data := &fftypes.Data{
   138  		Value: fftypes.Byteable(b),
   139  	}
   140  
   141  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   142  		Header: fftypes.MessageHeader{
   143  			Tag: string(fftypes.SystemTagDefineNamespace),
   144  		},
   145  	}, []*fftypes.Data{data})
   146  	assert.False(t, valid)
   147  	assert.NoError(t, err)
   148  }
   149  
   150  func TestHandleSystemBroadcastNSBadData(t *testing.T) {
   151  	bm, cancel := newTestBroadcast(t)
   152  	defer cancel()
   153  
   154  	data := &fftypes.Data{
   155  		Value: fftypes.Byteable(`!{json`),
   156  	}
   157  
   158  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   159  		Header: fftypes.MessageHeader{
   160  			Tag: string(fftypes.SystemTagDefineNamespace),
   161  		},
   162  	}, []*fftypes.Data{data})
   163  	assert.False(t, valid)
   164  	assert.NoError(t, err)
   165  }
   166  
   167  func TestHandleSystemBroadcastDuplicate(t *testing.T) {
   168  	bm, cancel := newTestBroadcast(t)
   169  	defer cancel()
   170  
   171  	ns := &fftypes.Namespace{
   172  		ID:   fftypes.NewUUID(),
   173  		Name: "ns1",
   174  	}
   175  	b, err := json.Marshal(&ns)
   176  	assert.NoError(t, err)
   177  	data := &fftypes.Data{
   178  		Value: fftypes.Byteable(b),
   179  	}
   180  
   181  	mdi := bm.database.(*databasemocks.Plugin)
   182  	mdi.On("GetNamespace", mock.Anything, "ns1").Return(ns, nil)
   183  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   184  		Header: fftypes.MessageHeader{
   185  			Tag: string(fftypes.SystemTagDefineNamespace),
   186  		},
   187  	}, []*fftypes.Data{data})
   188  	assert.False(t, valid)
   189  	assert.NoError(t, err)
   190  
   191  	mdi.AssertExpectations(t)
   192  }
   193  
   194  func TestHandleSystemBroadcastDuplicateOverrideLocal(t *testing.T) {
   195  	bm, cancel := newTestBroadcast(t)
   196  	defer cancel()
   197  
   198  	ns := &fftypes.Namespace{
   199  		ID:   fftypes.NewUUID(),
   200  		Name: "ns1",
   201  		Type: fftypes.NamespaceTypeLocal,
   202  	}
   203  	b, err := json.Marshal(&ns)
   204  	assert.NoError(t, err)
   205  	data := &fftypes.Data{
   206  		Value: fftypes.Byteable(b),
   207  	}
   208  
   209  	mdi := bm.database.(*databasemocks.Plugin)
   210  	mdi.On("GetNamespace", mock.Anything, "ns1").Return(ns, nil)
   211  	mdi.On("DeleteNamespace", mock.Anything, mock.Anything).Return(nil)
   212  	mdi.On("UpsertNamespace", mock.Anything, mock.Anything, false).Return(nil)
   213  	mdi.On("UpsertEvent", mock.Anything, mock.Anything, false).Return(nil)
   214  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   215  		Header: fftypes.MessageHeader{
   216  			Tag: string(fftypes.SystemTagDefineNamespace),
   217  		},
   218  	}, []*fftypes.Data{data})
   219  	assert.True(t, valid)
   220  	assert.NoError(t, err)
   221  
   222  	mdi.AssertExpectations(t)
   223  }
   224  
   225  func TestHandleSystemBroadcastDuplicateOverrideLocalFail(t *testing.T) {
   226  	bm, cancel := newTestBroadcast(t)
   227  	defer cancel()
   228  
   229  	ns := &fftypes.Namespace{
   230  		ID:   fftypes.NewUUID(),
   231  		Name: "ns1",
   232  		Type: fftypes.NamespaceTypeLocal,
   233  	}
   234  	b, err := json.Marshal(&ns)
   235  	assert.NoError(t, err)
   236  	data := &fftypes.Data{
   237  		Value: fftypes.Byteable(b),
   238  	}
   239  
   240  	mdi := bm.database.(*databasemocks.Plugin)
   241  	mdi.On("GetNamespace", mock.Anything, "ns1").Return(ns, nil)
   242  	mdi.On("DeleteNamespace", mock.Anything, mock.Anything).Return(fmt.Errorf("pop"))
   243  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   244  		Header: fftypes.MessageHeader{
   245  			Tag: string(fftypes.SystemTagDefineNamespace),
   246  		},
   247  	}, []*fftypes.Data{data})
   248  	assert.False(t, valid)
   249  	assert.EqualError(t, err, "pop")
   250  
   251  	mdi.AssertExpectations(t)
   252  }
   253  
   254  func TestHandleSystemBroadcastDupCheckFail(t *testing.T) {
   255  	bm, cancel := newTestBroadcast(t)
   256  	defer cancel()
   257  
   258  	ns := &fftypes.Namespace{
   259  		ID:   fftypes.NewUUID(),
   260  		Name: "ns1",
   261  	}
   262  	b, err := json.Marshal(&ns)
   263  	assert.NoError(t, err)
   264  	data := &fftypes.Data{
   265  		Value: fftypes.Byteable(b),
   266  	}
   267  
   268  	mdi := bm.database.(*databasemocks.Plugin)
   269  	mdi.On("GetNamespace", mock.Anything, "ns1").Return(nil, fmt.Errorf("pop"))
   270  	valid, err := bm.HandleSystemBroadcast(context.Background(), &fftypes.Message{
   271  		Header: fftypes.MessageHeader{
   272  			Tag: string(fftypes.SystemTagDefineNamespace),
   273  		},
   274  	}, []*fftypes.Data{data})
   275  	assert.False(t, valid)
   276  	assert.EqualError(t, err, "pop")
   277  
   278  	mdi.AssertExpectations(t)
   279  }