github.com/filecoin-project/bacalhau@v0.3.23-0.20230228154132-45c989550ace/pkg/publisher/combo/piggyback_test.go (about)

     1  //go:build unit || !integration
     2  
     3  package combo
     4  
     5  import (
     6  	"context"
     7  	"errors"
     8  	"testing"
     9  
    10  	"github.com/filecoin-project/bacalhau/pkg/model"
    11  	"github.com/filecoin-project/bacalhau/pkg/publisher"
    12  	"github.com/stretchr/testify/assert"
    13  	"github.com/stretchr/testify/mock"
    14  )
    15  
    16  func TestPiggybackedPublisher_IsInstalled(t *testing.T) {
    17  	for _, test := range []struct {
    18  		name        string
    19  		primary     []interface{}
    20  		piggyback   []interface{}
    21  		expected    bool
    22  		expectedErr error
    23  	}{
    24  		{
    25  			name:        "all_successful",
    26  			primary:     []interface{}{true, nil},
    27  			piggyback:   []interface{}{true, nil},
    28  			expected:    true,
    29  			expectedErr: nil,
    30  		},
    31  		{
    32  			name:        "primary_error",
    33  			primary:     []interface{}{false, errors.New("failed")},
    34  			piggyback:   []interface{}{true, nil},
    35  			expected:    false,
    36  			expectedErr: errors.New("failed"),
    37  		},
    38  		{
    39  			name:        "piggyback_error",
    40  			primary:     []interface{}{true, nil},
    41  			piggyback:   []interface{}{true, errors.New("failed")},
    42  			expected:    false,
    43  			expectedErr: errors.New("failed"),
    44  		},
    45  		{
    46  			name:        "primary_not_installed",
    47  			primary:     []interface{}{false, nil},
    48  			piggyback:   []interface{}{true, nil},
    49  			expected:    false,
    50  			expectedErr: nil,
    51  		},
    52  		{
    53  			name:        "piggyback_not_installed",
    54  			primary:     []interface{}{true, nil},
    55  			piggyback:   []interface{}{false, nil},
    56  			expected:    false,
    57  			expectedErr: nil,
    58  		},
    59  	} {
    60  		t.Run(test.name, func(t *testing.T) {
    61  			primary := new(testifyPublisher)
    62  			piggyback := new(testifyPublisher)
    63  
    64  			subject := NewPiggybackedPublisher(primary, piggyback)
    65  
    66  			primary.On("IsInstalled", mock.Anything).Return(test.primary...)
    67  			piggyback.On("IsInstalled", mock.Anything).Return(test.piggyback...)
    68  
    69  			actual, err := subject.IsInstalled(context.Background())
    70  			assert.Equal(t, test.expectedErr, err)
    71  			assert.Equal(t, test.expected, actual)
    72  		})
    73  	}
    74  }
    75  
    76  func TestPiggybackedPublisher_PublishShardResult(t *testing.T) {
    77  	for _, test := range []struct {
    78  		name        string
    79  		primary     []interface{}
    80  		piggyback   []interface{}
    81  		expected    model.StorageSpec
    82  		expectedErr error
    83  	}{
    84  		{
    85  			name:        "all_successful",
    86  			primary:     []interface{}{model.StorageSpec{Name: "primary", StorageSource: model.StorageSourceIPFS, CID: "123"}, nil},
    87  			piggyback:   []interface{}{model.StorageSpec{Name: "piggy", StorageSource: model.StorageSourceFilecoin, CID: "456"}, nil},
    88  			expected:    model.StorageSpec{Name: "primary", StorageSource: model.StorageSourceIPFS, CID: "123", Metadata: map[string]string{"Filecoin": "456"}},
    89  			expectedErr: nil,
    90  		},
    91  		{
    92  			name:        "primary_error",
    93  			primary:     []interface{}{model.StorageSpec{}, errors.New("failed")},
    94  			piggyback:   []interface{}{model.StorageSpec{Name: "piggy"}, nil},
    95  			expected:    model.StorageSpec{},
    96  			expectedErr: errors.New("failed"),
    97  		},
    98  		{
    99  			name:        "piggyback_error",
   100  			primary:     []interface{}{model.StorageSpec{Name: "primary"}, nil},
   101  			piggyback:   []interface{}{model.StorageSpec{}, errors.New("failed")},
   102  			expected:    model.StorageSpec{},
   103  			expectedErr: errors.New("failed"),
   104  		},
   105  	} {
   106  		t.Run(test.name, func(t *testing.T) {
   107  			primary := new(testifyPublisher)
   108  			piggyback := new(testifyPublisher)
   109  
   110  			subject := NewPiggybackedPublisher(primary, piggyback)
   111  
   112  			shard := model.JobShard{Index: 4}
   113  			hostId := "host"
   114  			resultsPath := "/some/path"
   115  
   116  			primary.On("PublishShardResult", mock.Anything, shard, hostId, resultsPath).Return(test.primary...)
   117  			piggyback.On("PublishShardResult", mock.Anything, shard, hostId, resultsPath).Return(test.piggyback...)
   118  
   119  			actual, err := subject.PublishShardResult(context.Background(), shard, hostId, resultsPath)
   120  			assert.Equal(t, test.expectedErr, err)
   121  			assert.Equal(t, test.expected, actual)
   122  		})
   123  	}
   124  }
   125  
   126  type testifyPublisher struct {
   127  	mock.Mock
   128  }
   129  
   130  func (t *testifyPublisher) IsInstalled(ctx context.Context) (bool, error) {
   131  	args := t.Called(ctx)
   132  	return args.Bool(0), args.Error(1)
   133  }
   134  
   135  func (t *testifyPublisher) PublishShardResult(ctx context.Context, shard model.JobShard, hostID string, shardResultPath string) (model.StorageSpec, error) {
   136  	args := t.Called(ctx, shard, hostID, shardResultPath)
   137  	return args.Get(0).(model.StorageSpec), args.Error(1)
   138  }
   139  
   140  func (t *testifyPublisher) ComposeResultReferences(ctx context.Context, jobID string) ([]model.StorageSpec, error) {
   141  	args := t.Called(ctx, jobID)
   142  	return args.Get(0).([]model.StorageSpec), args.Error(1)
   143  }
   144  
   145  var _ publisher.Publisher = &testifyPublisher{}