github.com/kaleido-io/firefly@v0.0.0-20210622132723-8b4b6aacb971/internal/broadcast/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  	"fmt"
    22  	"testing"
    23  
    24  	"github.com/kaleido-io/firefly/mocks/databasemocks"
    25  	"github.com/kaleido-io/firefly/mocks/datamocks"
    26  	"github.com/kaleido-io/firefly/pkg/fftypes"
    27  	"github.com/stretchr/testify/assert"
    28  	"github.com/stretchr/testify/mock"
    29  )
    30  
    31  func TestBroadcastDatatypeBadType(t *testing.T) {
    32  	bm, cancel := newTestBroadcast(t)
    33  	defer cancel()
    34  	_, err := bm.BroadcastDatatype(context.Background(), "ns1", &fftypes.Datatype{
    35  		Validator: fftypes.ValidatorType("wrong"),
    36  	})
    37  	assert.Regexp(t, "FF10132.*validator", err)
    38  }
    39  
    40  func TestBroadcastDatatypeNSGetFail(t *testing.T) {
    41  	bm, cancel := newTestBroadcast(t)
    42  	defer cancel()
    43  	mdm := bm.data.(*datamocks.Manager)
    44  	mdm.On("VerifyNamespaceExists", mock.Anything, "ns1").Return(fmt.Errorf("pop"))
    45  	_, err := bm.BroadcastDatatype(context.Background(), "ns1", &fftypes.Datatype{
    46  		Name:      "name1",
    47  		Namespace: "ns1",
    48  		Version:   "0.0.1",
    49  		Value:     fftypes.Byteable(`{}`),
    50  	})
    51  	assert.EqualError(t, err, "pop")
    52  }
    53  
    54  func TestBroadcastDatatypeBadValue(t *testing.T) {
    55  	bm, cancel := newTestBroadcast(t)
    56  	defer cancel()
    57  	mdm := bm.data.(*datamocks.Manager)
    58  	mdm.On("VerifyNamespaceExists", mock.Anything, "ns1").Return(nil)
    59  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(nil)
    60  	_, err := bm.BroadcastDatatype(context.Background(), "ns1", &fftypes.Datatype{
    61  		Namespace: "ns1",
    62  		Name:      "ent1",
    63  		Version:   "0.0.1",
    64  		Value:     fftypes.Byteable(`!unparsable`),
    65  	})
    66  	assert.Regexp(t, "FF10137.*value", err)
    67  }
    68  
    69  func TestBroadcastUpsertFail(t *testing.T) {
    70  	bm, cancel := newTestBroadcast(t)
    71  	defer cancel()
    72  	mdi := bm.database.(*databasemocks.Plugin)
    73  	mdm := bm.data.(*datamocks.Manager)
    74  
    75  	mdi.On("UpsertData", mock.Anything, mock.Anything, true, false).Return(fmt.Errorf("pop"))
    76  	mdm.On("VerifyNamespaceExists", mock.Anything, "ns1").Return(nil)
    77  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(nil)
    78  
    79  	_, err := bm.BroadcastDatatype(context.Background(), "ns1", &fftypes.Datatype{
    80  		Namespace: "ns1",
    81  		Name:      "ent1",
    82  		Version:   "0.0.1",
    83  		Value:     fftypes.Byteable(`{"some": "data"}`),
    84  	})
    85  	assert.EqualError(t, err, "pop")
    86  }
    87  
    88  func TestBroadcastDatatypeInvalid(t *testing.T) {
    89  	bm, cancel := newTestBroadcast(t)
    90  	defer cancel()
    91  	mdi := bm.database.(*databasemocks.Plugin)
    92  	mdm := bm.data.(*datamocks.Manager)
    93  
    94  	mdi.On("UpsertData", mock.Anything, mock.Anything, true, false).Return(nil)
    95  	mdm.On("VerifyNamespaceExists", mock.Anything, "ns1").Return(nil)
    96  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(fmt.Errorf("pop"))
    97  
    98  	_, err := bm.BroadcastDatatype(context.Background(), "ns1", &fftypes.Datatype{
    99  		Namespace: "ns1",
   100  		Name:      "ent1",
   101  		Version:   "0.0.1",
   102  		Value:     fftypes.Byteable(`{"some": "data"}`),
   103  	})
   104  	assert.EqualError(t, err, "pop")
   105  }
   106  
   107  func TestBroadcastBroadcastFail(t *testing.T) {
   108  	bm, cancel := newTestBroadcast(t)
   109  	defer cancel()
   110  	mdi := bm.database.(*databasemocks.Plugin)
   111  	mdm := bm.data.(*datamocks.Manager)
   112  
   113  	mdi.On("UpsertData", mock.Anything, mock.Anything, true, false).Return(nil)
   114  	mdm.On("VerifyNamespaceExists", mock.Anything, "ns1").Return(nil)
   115  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(nil)
   116  	mdi.On("InsertMessageLocal", mock.Anything, mock.Anything).Return(fmt.Errorf("pop"))
   117  
   118  	_, err := bm.BroadcastDatatype(context.Background(), "ns1", &fftypes.Datatype{
   119  		Namespace: "ns1",
   120  		Name:      "ent1",
   121  		Version:   "0.0.1",
   122  		Value:     fftypes.Byteable(`{"some": "data"}`),
   123  	})
   124  	assert.EqualError(t, err, "pop")
   125  }
   126  
   127  func TestBroadcastOk(t *testing.T) {
   128  	bm, cancel := newTestBroadcast(t)
   129  	defer cancel()
   130  	mdi := bm.database.(*databasemocks.Plugin)
   131  	mdm := bm.data.(*datamocks.Manager)
   132  
   133  	mdi.On("UpsertData", mock.Anything, mock.Anything, true, false).Return(nil)
   134  	mdm.On("VerifyNamespaceExists", mock.Anything, "ns1").Return(nil)
   135  	mdm.On("CheckDatatype", mock.Anything, "ns1", mock.Anything).Return(nil)
   136  	mdi.On("InsertMessageLocal", mock.Anything, mock.Anything).Return(nil)
   137  
   138  	_, err := bm.BroadcastDatatype(context.Background(), "ns1", &fftypes.Datatype{
   139  		Namespace: "ns1",
   140  		Name:      "ent1",
   141  		Version:   "0.0.1",
   142  		Value:     fftypes.Byteable(`{"some": "data"}`),
   143  	})
   144  	assert.NoError(t, err)
   145  }