func setup(t *testing.T) (
rcStore rcstore.Store,
kpStore fakeKpStore,
applicator labels.Applicator,
rc ReplicationController) {
rcStore = rcstore.NewFake()
manifestBuilder := pods.NewManifestBuilder()
manifestBuilder.SetID("testPod")
manifest := manifestBuilder.GetManifest()
nodeSelector := klabels.Everything().Add("nodeQuality", klabels.EqualsOperator, []string{"good"})
podLabels := map[string]string{"podTest": "successful"}
rcData, err := rcStore.Create(manifest, nodeSelector, podLabels)
Assert(t).IsNil(err, "expected no error creating request")
kpStore = fakeKpStore{manifests: make(map[string]pods.Manifest)}
applicator = labels.NewFakeApplicator()
rc = New(
rcData,
&kpStore,
rcStore,
NewApplicatorScheduler(applicator),
applicator,
logging.DefaultLogger,
)
return
}
func newRollStore(t *testing.T, entries []fields.Update) consulStore {
storeFields := make(map[string]*api.KVPair)
for _, u := range entries {
path, err := RollPath(fields.ID(u.NewRC))
if err != nil {
t.Fatalf("Unable to create roll store for test: %s", err)
}
json, err := json.Marshal(u)
if err != nil {
t.Fatalf("Unable to marshal test field as JSON: %s", err)
}
storeFields[path] = &api.KVPair{
Key: path,
Value: json,
}
}
return consulStore{
kv: &consulutil.FakeKV{
Entries: storeFields,
},
store: kptest.NewFakePodStore(nil, nil),
rcstore: rcstore.NewFake(),
labeler: labels.NewFakeApplicator(),
}
}
func TestLockRCs(t *testing.T) {
fakeStore := kptest.NewFakePodStore(nil, nil)
session, _, err := fakeStore.NewSession("fake rc lock session", nil)
Assert(t).IsNil(err, "Should not have erred getting fake session")
update := NewUpdate(fields.Update{
NewRC: rc_fields.ID("new_rc"),
OldRC: rc_fields.ID("old_rc"),
},
nil,
rcstore.NewFake(),
nil,
nil,
nil,
logging.DefaultLogger,
session,
nil,
).(*update)
err = update.lockRCs(make(<-chan struct{}))
Assert(t).IsNil(err, "should not have erred locking RCs")
Assert(t).IsNotNil(update.newRCUnlocker, "should have consulutil.Unlocker for unlocking new rc")
Assert(t).IsNotNil(update.oldRCUnlocker, "should have consulutil.Unlocker for unlocking old rc")
}
func updateWithHealth(t *testing.T,
desiredOld, desiredNew int,
oldNodes, newNodes map[types.NodeName]bool,
checks map[types.NodeName]health.Result,
) (update, manifest.Manifest, manifest.Manifest) {
podID := "mypod"
oldManifest := podWithIDAndPort(podID, 9001)
newManifest := podWithIDAndPort(podID, 9002)
podMap := map[kptest.FakePodStoreKey]manifest.Manifest{}
assignManifestsToNodes(types.PodID(podID), oldNodes, podMap, oldManifest, newManifest)
assignManifestsToNodes(types.PodID(podID), newNodes, podMap, newManifest, oldManifest)
kps := kptest.NewFakePodStore(podMap, nil)
rcs := rcstore.NewFake()
applicator := labels.NewFakeApplicator()
oldRC, err := createRC(rcs, applicator, oldManifest, desiredOld, oldNodes)
Assert(t).IsNil(err, "expected no error setting up old RC")
newRC, err := createRC(rcs, applicator, newManifest, desiredNew, newNodes)
Assert(t).IsNil(err, "expected no error setting up new RC")
return update{
kps: kps,
rcs: rcs,
hcheck: checkertest.NewSingleService(podID, checks),
labeler: applicator,
logger: logging.TestLogger(),
Update: fields.Update{
OldRC: oldRC.ID,
NewRC: newRC.ID,
},
}, oldManifest, newManifest
}
