func TestReadState(t *testing.T) {
dsm := NewDiskStateManager("testdata/in")
actual, err := dsm.ReadState()
if err != nil {
t.Fatal(err)
}
expected := exampleState()
actualYAML, err := yaml.Marshal(actual)
if err != nil {
t.Fatal(err)
}
expectedYAML, err := yaml.Marshal(expected)
if err != nil {
t.Fatal(err)
}
if string(actualYAML) != string(expectedYAML) {
t.Log("Expected >>>>>>>>>>>>>>>>>")
t.Logf("\n% +v", string(expectedYAML))
t.Log("Got >>>>>>>>>>>>>>>>>>>>>>")
t.Logf("\n% +v", string(actualYAML))
t.Fatal("")
}
}
// SuccessYAML lets you return YAML on the command line.
func SuccessYAML(v interface{}) cmdr.Result {
b, err := yaml.Marshal(v)
if err != nil {
return InternalErrorf("unable to marshal YAML: %s", err)
}
return SuccessData(b)
}
// Bytes marshals the config to a []byte
func (c *LocalSousConfig) Bytes() []byte {
y, err := yaml.Marshal(c.Config)
if err != nil {
panic("error marshalling config as yaml:" + err.Error())
}
return y
}
func sameYAML(t *testing.T, actual *sous.State, expected *sous.State) {
assert := assert.New(t)
require := require.New(t)
actualManifests := actual.Manifests.Snapshot()
expectedManifests := expected.Manifests.Snapshot()
assert.Len(actualManifests, len(expectedManifests))
for mid, manifest := range expectedManifests {
actual := *actualManifests[mid]
assert.Contains(actualManifests, mid)
if !assert.Equal(actual, *manifest) {
_, differences := actual.Diff(manifest)
t.Logf("DIFFERENCES (%q): %#v", mid, differences)
}
}
actualYAML, err := yaml.Marshal(actual)
require.NoError(err)
expectedYAML, err := yaml.Marshal(expected)
require.NoError(err)
assert.Equal(actualYAML, expectedYAML)
}
