prepare 2.0.0-beta.2 release

go.mod

@@ -3,6 +3,6 @@ module gopkg.in/launchdarkly/go-sdk-common.v2
 go 1.13
 
 require (
-	github.com/launchdarkly/go-test-helpers v1.1.3
+	github.com/launchdarkly/go-test-helpers/v2 v2.2.0
 	github.com/stretchr/testify v1.6.1
 )

go.sum

@@ -2,9 +2,8 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/launchdarkly/eventsource v0.0.0-20190617224151-6b837031c9ca/go.mod h1:y6+/PY1Az/AQyjCMsFt5mOZq1tfM0/KOQRS4f0pVe3M=
-github.com/launchdarkly/go-test-helpers v1.1.3 h1:SgliO/iURt4AgQwuu27HFsDCqRenUvpM/5Um+Op+1hw=
-github.com/launchdarkly/go-test-helpers v1.1.3/go.mod h1:bdm93TgmHJ/CbNIN5BpbZsaoIbd9ZVexRrINSBPz+DE=
+github.com/launchdarkly/go-test-helpers/v2 v2.2.0 h1:L3kGILP/6ewikhzhdNkHy1b5y4zs50LueWenVF0sBbs=
+github.com/launchdarkly/go-test-helpers/v2 v2.2.0/go.mod h1:L7+th5govYp5oKU9iN7To5PgznBuIjBPn+ejqKR0avw=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
@@ -14,7 +13,6 @@ github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/launchdarkly/go-sdk-common.v1 v1.0.0-20200204015611-d48d1b4f4e70/go.mod h1:2kE5FCTDQ53bqRSOfJpE5fdiAQYiN9LESONDNyEBFjI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=

ldlog/package_info.go

@@ -2,4 +2,6 @@
 //
 // These types and methods allow you to customize the logging behavior of the SDK, such as
 // filtering log output by level or redirecting it to another destination.
+//
+// For a test implementation that captures output, see the ldlogtest package.
 package ldlog

ldlogtest/mock_log.go

@@ -0,0 +1,130 @@
+package ldlogtest
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"gopkg.in/launchdarkly/go-sdk-common.v2/ldlog"
+)
+
+// MockLogItem represents a log message captured by MockLog.
+type MockLogItem struct {
+	Level   ldlog.LogLevel
+	Message string
+}
+
+// MockLog provides the ability to capture log output.
+//
+// It contains a Loggers instance which can be used like any other Loggers, but all of the output is
+// captured by the enclosing MockLog and can be retrieved with the MockLog methods.
+//
+//     mockLog := ldlogtest.NewMockLog()
+//     mockLog.Loggers.Warn("message")
+//     mockLog.Loggers.Warnf("also: %t", true)
+//     warnMessages := mockLog.GetOutput(ldlog.Warn) // returns {"message", "also: true"}
+type MockLog struct {
+	// Loggers is the ldlog.Loggers instance to be used for tests.
+	Loggers ldlog.Loggers
+	// Output is a map containing all of the lines logged for each level. The level prefix is removed from the text.
+	output map[ldlog.LogLevel][]string
+	// AllOutput is a list of all the log output for any level in order. The level prefix is removed from the text.
+	allOutput []MockLogItem
+	lock      sync.Mutex
+}
+
+// NewMockLog creates a log-capturing object.
+func NewMockLog() *MockLog {
+	ret := &MockLog{output: make(map[ldlog.LogLevel][]string)}
+	for _, level := range []ldlog.LogLevel{ldlog.Debug, ldlog.Info, ldlog.Warn, ldlog.Error} {
+		ret.Loggers.SetBaseLoggerForLevel(level, mockBaseLogger{owner: ret, level: level})
+	}
+	return ret
+}
+
+// GetOutput returns the captured output for a specific log level.
+func (ml *MockLog) GetOutput(level ldlog.LogLevel) []string {
+	ml.lock.Lock()
+	defer ml.lock.Unlock()
+	lines := ml.output[level]
+	ret := make([]string, len(lines))
+	copy(ret, lines)
+	return ret
+}
+
+// GetAllOutput returns the captured output for all log levels.
+func (ml *MockLog) GetAllOutput() []MockLogItem {
+	ml.lock.Lock()
+	defer ml.lock.Unlock()
+	ret := make([]MockLogItem, len(ml.allOutput))
+	copy(ret, ml.allOutput)
+	return ret
+}
+
+// HasMessageMatch tests whether there is a log message of this level that matches this regex.
+func (ml *MockLog) HasMessageMatch(level ldlog.LogLevel, pattern string) bool {
+	_, found := ml.findMessageMatching(level, pattern)
+	return found
+}
+
+// AssertMessageMatch asserts whether there is a log message of this level that matches this regex.
+// This is equivalent to using assert.True or assert.False with HasMessageMatch, except that if the
+// test fails, it includes the actual log messages in the failure message.
+func (ml *MockLog) AssertMessageMatch(t *testing.T, shouldMatch bool, level ldlog.LogLevel, pattern string) {
+	line, hasMatch := ml.findMessageMatching(level, pattern)
+	if hasMatch != shouldMatch {
+		if shouldMatch {
+			assert.Fail(
+				t,
+				"log did not contain expected message",
+				"level: %s, pattern: /%s/, messages: %v",
+				level,
+				pattern,
+				ml.GetOutput(level),
+			)
+		} else {
+			assert.Fail(
+				t,
+				"log contained unexpected message",
+				"level: %s, message: [%s]",
+				level,
+				line,
+			)
+		}
+	}
+}
+
+func (ml *MockLog) logLine(level ldlog.LogLevel, line string) {
+	ml.lock.Lock()
+	defer ml.lock.Unlock()
+	message := strings.TrimPrefix(line, strings.ToUpper(level.String())+": ")
+	ml.output[level] = append(ml.output[level], message)
+	ml.allOutput = append(ml.allOutput, MockLogItem{level, message})
+}
+
+func (ml *MockLog) findMessageMatching(level ldlog.LogLevel, pattern string) (string, bool) {
+	r := regexp.MustCompile(pattern)
+	for _, line := range ml.GetOutput(level) {
+		if r.MatchString(line) {
+			return line, true
+		}
+	}
+	return "", false
+}
+
+type mockBaseLogger struct {
+	owner *MockLog
+	level ldlog.LogLevel
+}
+
+func (l mockBaseLogger) Println(values ...interface{}) {
+	l.owner.logLine(l.level, strings.TrimSuffix(fmt.Sprintln(values...), "\n"))
+}
+
+func (l mockBaseLogger) Printf(format string, values ...interface{}) {
+	l.owner.logLine(l.level, fmt.Sprintf(format, values...))
+}

ldlogtest/mock_log_test.go

@@ -0,0 +1,76 @@
+package ldlogtest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"gopkg.in/launchdarkly/go-sdk-common.v2/ldlog"
+)
+
+type mockLogTestValues struct {
+	level     ldlog.LogLevel
+	nextLevel ldlog.LogLevel
+	println   func(ldlog.Loggers, ...interface{})
+	printf    func(ldlog.Loggers, string, ...interface{})
+}
+
+var allTestValues = []mockLogTestValues{
+	{ldlog.Debug, ldlog.Info, ldlog.Loggers.Debug, ldlog.Loggers.Debugf},
+	{ldlog.Info, ldlog.Warn, ldlog.Loggers.Info, ldlog.Loggers.Infof},
+	{ldlog.Warn, ldlog.Error, ldlog.Loggers.Warn, ldlog.Loggers.Warnf},
+	{ldlog.Error, ldlog.None, ldlog.Loggers.Error, ldlog.Loggers.Errorf},
+}
+
+func TestMockLogCapturesMessagesForLevel(t *testing.T) {
+	for _, v := range allTestValues {
+		t.Run(v.level.String(), func(t *testing.T) {
+			m := NewMockLog()
+			m.Loggers.SetMinLevel(v.level)
+			v.println(m.Loggers, "hello")
+			v.printf(m.Loggers, "yes: %t", true)
+
+			m.Loggers.SetMinLevel(v.nextLevel)
+			v.println(m.Loggers, "shouldn't see this")
+
+			o1 := m.GetOutput(v.level)
+			assert.Equal(t, []string{"hello", "yes: true"}, o1)
+
+			o2 := m.GetAllOutput()
+			assert.Equal(t, []MockLogItem{
+				{v.level, "hello"},
+				{v.level, "yes: true"},
+			}, o2)
+		})
+	}
+}
+
+func TestMessageMatching(t *testing.T) {
+	m := NewMockLog()
+	m.Loggers.Info("first")
+	m.Loggers.Info("second")
+	m.Loggers.Warn("third")
+
+	testShouldFail := func(t *testing.T, action func(*testing.T)) {
+		var tt testing.T
+		action(&tt)
+		assert.True(t, tt.Failed(), "test should have failed")
+	}
+
+	shouldMatch := func(t *testing.T, level ldlog.LogLevel, pattern string) {
+		assert.True(t, m.HasMessageMatch(level, pattern))
+		m.AssertMessageMatch(t, true, level, pattern)
+		testShouldFail(t, func(tt *testing.T) { m.AssertMessageMatch(tt, false, level, pattern) })
+	}
+
+	shouldNotMatch := func(t *testing.T, level ldlog.LogLevel, pattern string) {
+		assert.False(t, m.HasMessageMatch(level, pattern))
+		m.AssertMessageMatch(t, false, level, pattern)
+		testShouldFail(t, func(tt *testing.T) { m.AssertMessageMatch(tt, true, level, pattern) })
+	}
+
+	shouldMatch(t, ldlog.Info, ".econd")
+	shouldMatch(t, ldlog.Warn, "t.*")
+	shouldNotMatch(t, ldlog.Info, "third")
+	shouldNotMatch(t, ldlog.Error, ".")
+}

ldlogtest/package_info.go

@@ -0,0 +1,7 @@
+// Package ldlogtest contains test helpers for use with the ldlog package.
+//
+// This package provides the MockLog type, which allows you to capture output that is sent to the
+// ldlog.Loggers API. This can be useful in test code for verifying that some component produces the
+// log output you expect it to. It is separate from the ldlog package because production code
+// normally will not use this tool.
+package ldlogtest

ldvalue/optional_string.go

@@ -39,15 +39,15 @@ func NewOptionalString(value string) OptionalString {
 }
 
 // NewOptionalStringFromPointer constructs an OptionalString from a string pointer. If the pointer
-// is non-nil, then the OptionalString copies its value; otherwise the OptionalString is empty.
+// is non-nil, then the OptionalString copies its value; otherwise the OptionalString has no value.
 func NewOptionalStringFromPointer(valuePointer *string) OptionalString {
 	if valuePointer == nil {
 		return OptionalString{hasValue: false}
 	}
 	return OptionalString{value: *valuePointer, hasValue: true}
 }
 
-// IsDefined returns true if the OptionalString contains a string value, or false if it is empty.
+// IsDefined returns true if the OptionalString contains a string value, or false if it has no value.
 func (o OptionalString) IsDefined() bool {
 	return o.hasValue
 }
@@ -71,6 +71,15 @@ func (o OptionalString) OrElse(valueIfEmpty string) string {
 	return valueIfEmpty
 }
 
+// OnlyIfNonEmptyString returns the same OptionalString unless it contains an empty string (""), in
+// which case it returns an OptionalString that has no value.
+func (o OptionalString) OnlyIfNonEmptyString() OptionalString {
+	if o.hasValue && o.value == "" {
+		return OptionalString{}
+	}
+	return o
+}
+
 // AsPointer returns the OptionalString's value as a string pointer if it has a value, or
 // nil otherwise.
 //
@@ -163,3 +172,28 @@ func (o OptionalString) WriteToJSONBuffer(j *jsonstream.JSONBuffer) {
 		j.WriteNull()
 	}
 }
+
+// MarshalText implements the encoding.TextMarshaler interface.
+//
+// Marshaling an empty OptionalString{} will return nil, rather than a zero-length slice.
+func (o OptionalString) MarshalText() ([]byte, error) {
+	if o.hasValue {
+		return []byte(o.value), nil
+	}
+	return nil, nil
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+//
+// This allows OptionalString to be used with packages that can parse text content, such as gcfg.
+//
+// If the byte slice is nil, rather than zero-length, it will set the target value to an empty
+// OptionalString{}. Otherwise, it will set it to a string value.
+func (o *OptionalString) UnmarshalText(text []byte) error {
+	if text == nil {
+		*o = OptionalString{}
+	} else {
+		*o = NewOptionalString(string(text))
+	}
+	return nil
+}

ldvalue/optional_string_test.go

@@ -56,13 +56,19 @@ func TestOptionalStringFromNonNilPointer(t *testing.T) {
 	assert.False(t, p == o.AsPointer()) // should not be the same pointer, just the same underlying string
 }
 
+func TestOptionalStringOnlyIfNonEmptyString(t *testing.T) {
+	assert.Equal(t, OptionalString{}, OptionalString{}.OnlyIfNonEmptyString())
+	assert.Equal(t, OptionalString{}, NewOptionalString("").OnlyIfNonEmptyString())
+	assert.Equal(t, NewOptionalString("x"), NewOptionalString("x").OnlyIfNonEmptyString())
+}
+
 func TestOptionalStringAsStringer(t *testing.T) {
 	assert.Equal(t, "[none]", OptionalString{}.String())
 	assert.Equal(t, "[empty]", NewOptionalString("").String())
 	assert.Equal(t, "x", NewOptionalString("x").String())
 }
 
-func TestOptionalStringMarshalling(t *testing.T) {
+func TestOptionalStringJSONMarshalling(t *testing.T) {
 	bytes, err := json.Marshal(OptionalString{})
 	assert.NoError(t, err)
 	assert.Equal(t, nullAsJSON, string(bytes))
@@ -85,7 +91,7 @@ func TestOptionalStringMarshalling(t *testing.T) {
 	assert.Equal(t, `"a \"good\" string",null`, string(bytes))
 }
 
-func TestOptionalStringUnmarshalling(t *testing.T) {
+func TestOptionalStringJSONUnmarshalling(t *testing.T) {
 	var o OptionalString
 	err := json.Unmarshal([]byte(nullAsJSON), &o)
 	assert.NoError(t, err)
@@ -113,3 +119,31 @@ type structWithOptionalStrings struct {
 	S2 OptionalString `json:"s2"`
 	S3 OptionalString `json:"s3"`
 }
+
+func TestOptionalStringTextMarshalling(t *testing.T) {
+	b, e := NewOptionalString("x").MarshalText()
+	assert.NoError(t, e)
+	assert.Equal(t, []byte("x"), b)
+
+	b, e = NewOptionalString("").MarshalText()
+	assert.NoError(t, e)
+	assert.Equal(t, []byte{}, b)
+
+	b, e = OptionalString{}.MarshalText()
+	assert.NoError(t, e)
+	assert.Nil(t, b)
+}
+
+func TestOptionalStringTextUnmarshalling(t *testing.T) {
+	var o1 OptionalString
+	assert.NoError(t, o1.UnmarshalText([]byte("x")))
+	assert.Equal(t, NewOptionalString("x"), o1)
+
+	var o2 OptionalString
+	assert.NoError(t, o2.UnmarshalText([]byte("")))
+	assert.Equal(t, NewOptionalString(""), o2)
+
+	var o3 OptionalString
+	assert.NoError(t, o3.UnmarshalText(nil))
+	assert.Equal(t, OptionalString{}, o3)
+}

ldvalue/value_base_test.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	helpers "github.com/launchdarkly/go-test-helpers"
+	helpers "github.com/launchdarkly/go-test-helpers/v2"
 )
 
 func TestValueTypes(t *testing.T) {