enable saving config between steps in a single feature

pkg/environment/magic.go

@@ -23,7 +23,9 @@ import (
 	"testing"
 
 	corev1 "k8s.io/api/core/v1"
+
 	"knative.dev/reconciler-test/pkg/feature"
+	"knative.dev/reconciler-test/pkg/state"
 )
 
 func NewGlobalEnvironment(ctx context.Context) GlobalEnvironment {
@@ -132,9 +134,19 @@ func (mr *MagicEnvironment) Prerequisite(ctx context.Context, t *testing.T, f *f
 	})
 }
 
+// Test implements Environment.Test.
+// In the MagicEnvironment implementation, the Store that is inside of the
+// Feature will be assigned to the context. If no Store is set on Feature,
+// Test will create a new store.KVStore and set it on the feature and then
+// apply it to the Context.
 func (mr *MagicEnvironment) Test(ctx context.Context, t *testing.T, f *feature.Feature) {
 	t.Helper() // Helper marks the calling function as a test helper function.
 
+	if f.State == nil {
+		f.State = &state.KVStore{}
+	}
+	ctx = state.ContextWith(ctx, f.State)
+
 	steps := feature.CollapseSteps(f.Steps)
 
 	for _, timing := range feature.Timings() {

pkg/feature/feature.go

@@ -19,12 +19,15 @@ package feature
 import (
 	"context"
 	"fmt"
+
+	"knative.dev/reconciler-test/pkg/state"
 )
 
 // Feature is a list of steps and feature name.
 type Feature struct {
 	Name  string
 	Steps []Step
+	State state.Store
 }
 
 // FeatureSet is a list of features and feature set name.

pkg/state/context.go

@@ -0,0 +1,70 @@
+/*
+Copyright 2021 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package state
+
+import (
+	"context"
+)
+
+type envKey struct{}
+
+// ContextWith decorates the given context with the provided Store, and returns
+// the resulting context.
+func ContextWith(ctx context.Context, s Store) context.Context {
+	return context.WithValue(ctx, envKey{}, s)
+}
+
+// FromContext returns the Store from Context, if not found FromContext will
+// panic.
+// TODO: revisit if we really want to panic here... likely not.
+func FromContext(ctx context.Context) Store {
+	if e, ok := ctx.Value(envKey{}).(Store); ok {
+		return e
+	}
+	panic("no Store found in context")
+}
+
+// Fail is defined to avoid circular dependency with the feature package.
+type fail interface {
+	Error(args ...interface{})
+}
+
+// Get the string value from the kvstore from key.
+func GetStringOrFail(ctx context.Context, t fail, key string) string {
+	value := ""
+	state := FromContext(ctx)
+	if err := state.Get(ctx, key, &value); err != nil {
+		t.Error(err)
+	}
+	return value
+}
+
+// Get gets the key from the Store into the provided value
+func GetOrFail(ctx context.Context, t fail, key string, value interface{}) {
+	state := FromContext(ctx)
+	if err := state.Get(ctx, key, value); err != nil {
+		t.Error(err)
+	}
+}
+
+// Set sets the key into the Store from the provided value
+func SetOrFail(ctx context.Context, t fail, key string, value interface{}) {
+	state := FromContext(ctx)
+	if err := state.Set(ctx, key, value); err != nil {
+		t.Error(err)
+	}
+}

pkg/state/interfaces.go

@@ -0,0 +1,27 @@
+/*
+Copyright 2021 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package state
+
+import "context"
+
+// This is a subset of knative.dev/pkg/kvstore.Interface
+type Store interface {
+	// Get gets the key from the Store into the provided value
+	Get(ctx context.Context, key string, value interface{}) error
+	// Set sets the key into the Store from the provided value
+	Set(ctx context.Context, key string, value interface{}) error
+}

pkg/state/kvstore.go

@@ -0,0 +1,67 @@
+/*
+Copyright 2021 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package state
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sync"
+)
+
+type KVStore struct {
+	store map[string]string
+	mux   sync.Mutex
+}
+
+// Get retrieves and unmarshals the value from the map.
+func (cs *KVStore) Get(_ context.Context, key string, value interface{}) error {
+	cs.mux.Lock()
+	defer cs.mux.Unlock()
+
+	if cs.store == nil {
+		cs.store = make(map[string]string)
+	}
+
+	v, ok := cs.store[key]
+
+	if !ok {
+		return fmt.Errorf("key %s does not exist", key)
+	}
+	err := json.Unmarshal([]byte(v), value)
+	if err != nil {
+		return fmt.Errorf("failed to Unmarshal %q: %v", v, err)
+	}
+	return nil
+}
+
+// Set marshals and sets the value given under specified key.
+func (cs *KVStore) Set(_ context.Context, key string, value interface{}) error {
+	cs.mux.Lock()
+	defer cs.mux.Unlock()
+
+	if cs.store == nil {
+		cs.store = make(map[string]string)
+	}
+
+	bytes, err := json.Marshal(value)
+	if err != nil {
+		return fmt.Errorf("failed to Marshal: %v", err)
+	}
+	cs.store[key] = string(bytes)
+	return nil
+}

pkg/state/kvstore_test.go

@@ -0,0 +1,91 @@
+/*
+Copyright 2021 The Knative Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package state
+
+import (
+	"context"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestKVStore_Get(t *testing.T) {
+	type test1 struct {
+		Foo string
+		Bar string
+	}
+
+	tests := []struct {
+		name    string
+		store   map[string]string
+		key     string
+		target  interface{}
+		want    interface{}
+		wantErr bool
+	}{{
+		name:  "nil store",
+		store: nil,
+		key:   "foo",
+		target: func() interface{} {
+			return ""
+		}(),
+		want:    "",
+		wantErr: true,
+	}, {
+		name: "found",
+		store: map[string]string{
+			"foo": `"bar"`,
+		},
+		key: "foo",
+		target: func() interface{} {
+			return ""
+		}(),
+		want:    "bar",
+		wantErr: false,
+	}, {
+		name: "found struct",
+		store: map[string]string{
+			"key": `{"Foo": "hello","Bar": "world"}`,
+		},
+		key: "key",
+		target: func() interface{} {
+			return test1{}
+		}(),
+		want: test1{
+			Foo: "hello",
+			Bar: "world",
+		},
+		wantErr: false,
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := KVStore{
+				store: tt.store,
+			}
+			err := s.Get(context.Background(), tt.key, &tt.target)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Get() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if err != nil {
+				if diff := cmp.Diff(tt.want, tt.target); diff != "" {
+					t.Error("Unexpected difference on return value (-want, +got):", diff)
+				}
+			}
+		})
+	}
+}

test/example/recorder_feature.go

@@ -17,13 +17,16 @@ limitations under the License.
 package example
 
 import (
+	"context"
 	"time"
 
+	cloudevents "github.com/cloudevents/sdk-go/v2"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 
 	"knative.dev/reconciler-test/pkg/eventshub"
 	"knative.dev/reconciler-test/pkg/feature"
 	"knative.dev/reconciler-test/pkg/k8s"
+	"knative.dev/reconciler-test/pkg/state"
 
 	// Dot import the eventshub asserts and sdk-go test packages to include all the assert utilities
 	. "github.com/cloudevents/sdk-go/v2/test"
@@ -33,22 +36,39 @@ import (
 func RecorderFeature() *feature.Feature {
 	svc := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "services"}
 
-	from := feature.MakeRandomK8sName("sender")
-	to := feature.MakeRandomK8sName("recorder")
-
 	f := new(feature.Feature)
 
-	event := FullEvent()
-
-	f.Setup("install recorder", eventshub.Install(to, eventshub.StartReceiver))
-	f.Setup("install sender", eventshub.Install(from, eventshub.StartSender(to), eventshub.InputEvent(event)))
-
-	f.Requirement("recorder is addressable", k8s.IsAddressable(svc, to, time.Second, 30*time.Second))
+	f.Setup("create an event", func(ctx context.Context, t feature.T) {
+		state.SetOrFail(ctx, t, "event", FullEvent())
+	})
+
+	f.Setup("install recorder", func(ctx context.Context, t feature.T) {
+		to := feature.MakeRandomK8sName("recorder")
+		eventshub.Install(to, eventshub.StartReceiver)
+		state.SetOrFail(ctx, t, "to", to)
+	})
+
+	f.Setup("install sender", func(ctx context.Context, t feature.T) {
+		to := state.GetStringOrFail(ctx, t, "to")
+		var event cloudevents.Event
+		state.GetOrFail(ctx, t, "event", &event)
+		from := feature.MakeRandomK8sName("sender")
+		eventshub.Install(from, eventshub.StartSender(to), eventshub.InputEvent(event))
+	})
+
+	f.Requirement("recorder is addressable", func(ctx context.Context, t feature.T) {
+		to := state.GetStringOrFail(ctx, t, "to")
+		k8s.IsAddressable(svc, to, time.Second, 30*time.Second)
+	})
 
 	f.Alpha("direct sending between a producer and a recorder").
 		Must("the recorder received all sent events within the time",
-			OnStore(to).MatchEvent(HasId(event.ID())).Exact(1),
-		)
+			func(ctx context.Context, t feature.T) {
+				to := state.GetStringOrFail(ctx, t, "to")
+				var event cloudevents.Event
+				state.GetOrFail(ctx, t, "event", &event)
+				OnStore(to).MatchEvent(HasId(event.ID())).Exact(1)
+			})
 
 	return f
 }