mock_data.go

Documentation: github.com/launchdarkly/go-server-sdk/v6/internal/sharedtest/mocks

     1  //nolint:gochecknoglobals
     2  package mocks
     3  
     4  import (
     5  	"errors"
     6  	"fmt"
     7  	"strconv"
     8  	"strings"
     9  
    10  	"github.com/launchdarkly/go-server-sdk/v6/subsystems/ldstoretypes"
    11  )
    12  
    13  // MakeMockDataSet constructs a data set to be passed to a data store's Init method.
    14  func MakeMockDataSet(items ...MockDataItem) []ldstoretypes.Collection {
    15  	itemsColl := ldstoretypes.Collection{
    16  		Kind:  MockData,
    17  		Items: []ldstoretypes.KeyedItemDescriptor{},
    18  	}
    19  	otherItemsColl := ldstoretypes.Collection{
    20  		Kind:  MockOtherData,
    21  		Items: []ldstoretypes.KeyedItemDescriptor{},
    22  	}
    23  	for _, item := range items {
    24  		d := ldstoretypes.KeyedItemDescriptor{
    25  			Key:  item.Key,
    26  			Item: item.ToItemDescriptor(),
    27  		}
    28  		if item.IsOtherKind {
    29  			otherItemsColl.Items = append(otherItemsColl.Items, d)
    30  		} else {
    31  			itemsColl.Items = append(itemsColl.Items, d)
    32  		}
    33  	}
    34  	return []ldstoretypes.Collection{itemsColl, otherItemsColl}
    35  }
    36  
    37  // MakeSerializedMockDataSet constructs a data set to be passed to a persistent data store's Init method.
    38  func MakeSerializedMockDataSet(items ...MockDataItem) []ldstoretypes.SerializedCollection {
    39  	itemsColl := ldstoretypes.SerializedCollection{
    40  		Kind:  MockData,
    41  		Items: []ldstoretypes.KeyedSerializedItemDescriptor{},
    42  	}
    43  	otherItemsColl := ldstoretypes.SerializedCollection{
    44  		Kind:  MockOtherData,
    45  		Items: []ldstoretypes.KeyedSerializedItemDescriptor{},
    46  	}
    47  	for _, item := range items {
    48  		d := ldstoretypes.KeyedSerializedItemDescriptor{
    49  			Key:  item.Key,
    50  			Item: item.ToSerializedItemDescriptor(),
    51  		}
    52  		if item.IsOtherKind {
    53  			otherItemsColl.Items = append(otherItemsColl.Items, d)
    54  		} else {
    55  			itemsColl.Items = append(itemsColl.Items, d)
    56  		}
    57  	}
    58  	return []ldstoretypes.SerializedCollection{itemsColl, otherItemsColl}
    59  }
    60  
    61  // MockDataItem is a test replacement for FeatureFlag/Segment.
    62  type MockDataItem struct {
    63  	Key         string
    64  	Version     int
    65  	Deleted     bool
    66  	Name        string
    67  	IsOtherKind bool
    68  }
    69  
    70  // ToItemDescriptor converts the test item to a StoreItemDescriptor.
    71  func (m MockDataItem) ToItemDescriptor() ldstoretypes.ItemDescriptor {
    72  	return ldstoretypes.ItemDescriptor{Version: m.Version, Item: m}
    73  }
    74  
    75  // ToKeyedItemDescriptor converts the test item to a StoreKeyedItemDescriptor.
    76  func (m MockDataItem) ToKeyedItemDescriptor() ldstoretypes.KeyedItemDescriptor {
    77  	return ldstoretypes.KeyedItemDescriptor{Key: m.Key, Item: m.ToItemDescriptor()}
    78  }
    79  
    80  // ToSerializedItemDescriptor converts the test item to a StoreSerializedItemDescriptor.
    81  func (m MockDataItem) ToSerializedItemDescriptor() ldstoretypes.SerializedItemDescriptor {
    82  	return ldstoretypes.SerializedItemDescriptor{
    83  		Version:        m.Version,
    84  		Deleted:        m.Deleted,
    85  		SerializedItem: MockData.Serialize(m.ToItemDescriptor()),
    86  	}
    87  }
    88  
    89  // MockData is an instance of ld.StoreDataKind corresponding to MockDataItem.
    90  var MockData = mockDataKind{isOther: false}
    91  
    92  type mockDataKind struct {
    93  	isOther bool
    94  }
    95  
    96  func (sk mockDataKind) GetName() string {
    97  	if sk.isOther {
    98  		return "mock2"
    99  	}
   100  	return "mock1"
   101  }
   102  
   103  func (sk mockDataKind) String() string {
   104  	return sk.GetName()
   105  }
   106  
   107  func (sk mockDataKind) Serialize(item ldstoretypes.ItemDescriptor) []byte {
   108  	if item.Item == nil {
   109  		return []byte(fmt.Sprintf("DELETED:%d", item.Version))
   110  	}
   111  	if mdi, ok := item.Item.(MockDataItem); ok {
   112  		return []byte(fmt.Sprintf("%s,%d,%t,%s,%t", mdi.Key, mdi.Version, mdi.Deleted, mdi.Name, mdi.IsOtherKind))
   113  	}
   114  	return nil
   115  }
   116  
   117  func (sk mockDataKind) Deserialize(data []byte) (ldstoretypes.ItemDescriptor, error) {
   118  	if data == nil {
   119  		return ldstoretypes.ItemDescriptor{}.NotFound(), errors.New("tried to deserialize nil data")
   120  	}
   121  	s := string(data)
   122  	if strings.HasPrefix(s, "DELETED:") {
   123  		v, _ := strconv.Atoi(strings.TrimPrefix(s, "DELETED:"))
   124  		return ldstoretypes.ItemDescriptor{Version: v}, nil
   125  	}
   126  	fields := strings.Split(s, ",")
   127  	if len(fields) == 5 {
   128  		v, _ := strconv.Atoi(fields[1])
   129  		itemIsOther := fields[4] == "true"
   130  		if itemIsOther != sk.isOther {
   131  			return ldstoretypes.ItemDescriptor{}.NotFound(), errors.New("got data item of wrong kind")
   132  		}
   133  		isDeleted := fields[2] == "true"
   134  		if isDeleted {
   135  			return ldstoretypes.ItemDescriptor{Version: v}, nil
   136  		}
   137  		m := MockDataItem{Key: fields[0], Version: v, Name: fields[3], IsOtherKind: itemIsOther}
   138  		return ldstoretypes.ItemDescriptor{Version: v, Item: m}, nil
   139  	}
   140  	return ldstoretypes.ItemDescriptor{}.NotFound(), fmt.Errorf(`not a valid MockDataItem: "%s"`, data)
   141  }
   142  
   143  // MockOtherData is an instance of ld.StoreDataKind corresponding to another flavor of MockDataItem.
   144  var MockOtherData = mockDataKind{isOther: true}
   145
View as plain text