asteris-llc/converge

// Copyright © 2016 Asteris, LLC
//
// 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 resource_test

import (
    "errors"
    "fmt"
    "testing"

    "github.com/asteris-llc/converge/healthcheck"
    "github.com/asteris-llc/converge/resource"
    "github.com/stretchr/testify/assert"
)

func Test_Status_ImplementsCheck(t *testing.T) {
    assert.Implements(t, (*healthcheck.Check)(nil), new(resource.Status))
}

// TestHasChanges exercises all the cases of HasChanges
func TestHasChanges(t *testing.T) {
    t.Parallel()

    // by default, statuses will not change
    t.Run("default", func(t *testing.T) {
        status := new(resource.Status)

        assert.False(t, status.HasChanges())
    })

    // Any diffs imply that this resource will change
    t.Run("diffs", func(t *testing.T) {
        status := new(resource.Status)
        status.AddDifference("x", "a", "b", "c")

        assert.True(t, status.HasChanges())
    })

    // Status level implies changes as well
    caseTable := []struct {
        level      resource.StatusLevel
        willChange bool
    }{
        {resource.StatusNoChange, false},
        {resource.StatusWontChange, false},
        {resource.StatusWillChange, true},
        {resource.StatusFatal, false},
        {resource.StatusCantChange, true},
    }
    for _, row := range caseTable {
        t.Run(
            fmt.Sprintf("status-%s", row.level),
            func(t *testing.T) {
                status := &resource.Status{
                    Level: row.level,
                }

                assert.Equal(t, row.willChange, status.HasChanges())
            },
        )
    }
}

// TestSetError makes sure that the level and error fields are set in all cases.
func TestSetError(t *testing.T) {
    t.Parallel()

    // test the translation of error levels
    fromTo := [][2]resource.StatusLevel{
        {resource.StatusNoChange, resource.StatusFatal},
        {resource.StatusWontChange, resource.StatusFatal},
        {resource.StatusWillChange, resource.StatusCantChange},
        {resource.StatusCantChange, resource.StatusCantChange},
        {resource.StatusFatal, resource.StatusFatal},
    }
    for _, pair := range fromTo {
        testErr := errors.New("test")

        t.Run(pair[0].String(), func(t *testing.T) {
            status := resource.NewStatus()
            status.Level = pair[0]
            status.SetError(testErr)

            assert.Equal(t, pair[1], status.Level, "%s != %s", pair[1], status.Level)
            assert.Equal(t, testErr, status.Error())
        })
    }
}

// TestSetWarning tests the SetWarning function on Status
func TestSetWarning(t *testing.T) {
    t.Parallel()
    status := resource.NewStatus()
    status.SetWarning("test")
    assert.Equal(t, "test", status.Warning())
}

// TestStatusError makes sure we always return a good error, even if error is
// not set.
func TestStatusError(t *testing.T) {
    t.Parallel()

    // when error is set, just return it
    t.Run("with error", func(t *testing.T) {
        err := errors.New("test")
        status := resource.NewStatus()
        status.SetError(err)

        assert.Equal(t, err, status.Error())
    })

    // otherwise, we'll have to return some generic stuff
    messages := []struct {
        level resource.StatusLevel
        err   error
    }{
        {resource.StatusNoChange, nil},
        {resource.StatusWontChange, nil},
        {resource.StatusWillChange, nil},
        {resource.StatusCantChange, resource.ErrStatusCantChange},
        {resource.StatusFatal, resource.ErrStatusFatal},
    }
    for _, msg := range messages {
        t.Run(msg.level.String(), func(t *testing.T) {
            status := resource.NewStatus()
            status.Level = msg.level
            assert.Equal(t, msg.err, status.Error())
        })
    }
}