(feat): Add test cases for layer.ShouldProcess()

internal/layer/directory_test.go

@@ -174,3 +174,40 @@ func TestCreateDirectoryLayerValidate(t *testing.T) {
 		})
 	}
 }
+
+func TestCreateDirectoryLayerShouldProcess(t *testing.T) {
+	subtests := []struct {
+		Name           string
+		Config         *config.Config
+		ExpectedOutput bool
+	}{
+		{
+			Name: "At Least Once Device Has Mount Point Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdb": {},
+					"/dev/xvdf": {
+						MountPoint: "/mnt/foo",
+					},
+				},
+			},
+			ExpectedOutput: true,
+		},
+		{
+			Name: "No Device Has Mount Point Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdf": {},
+				},
+			},
+			ExpectedOutput: false,
+		},
+	}
+	for _, subtest := range subtests {
+		t.Run(subtest.Name, func(t *testing.T) {
+			cdl := NewCreateDirectoryLayer(nil)
+			value := cdl.ShouldProcess(subtest.Config)
+			utils.CheckOutput("cdl.ShouldProcess()", t, subtest.ExpectedOutput, value)
+		})
+	}
+}

internal/layer/format_test.go

@@ -166,3 +166,30 @@ func TestFormatDeviceLayerValidate(t *testing.T) {
 		})
 	}
 }
+
+func TestFormatDeviceLayerShouldProcess(t *testing.T) {
+	subtests := []struct {
+		Name           string
+		Config         *config.Config
+		ExpectedOutput bool
+	}{
+		{
+			Name: "File System Declared",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdf": {
+						Fs: model.Xfs,
+					},
+				},
+			},
+			ExpectedOutput: true,
+		},
+	}
+	for _, subtest := range subtests {
+		t.Run(subtest.Name, func(t *testing.T) {
+			ld := NewFormatDeviceLayer(nil)
+			output := ld.ShouldProcess(subtest.Config)
+			utils.CheckOutput("ld.ShouldProcess()", t, subtest.ExpectedOutput, output)
+		})
+	}
+}

internal/layer/label_test.go

@@ -219,3 +219,45 @@ func TestLabelDeviceLayerValidate(t *testing.T) {
 		})
 	}
 }
+
+func TestLabelDeviceLayerShouldProcess(t *testing.T) {
+	subtests := []struct {
+		Name          string
+		Config        *config.Config
+		ExpectedValue bool
+	}{
+		{
+			Name: "At Least Once Device Has Label Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdb": {
+						Fs:    model.Ext4,
+						Label: "label",
+					},
+					"/dev/xvdf": {
+						Fs: model.Ext4,
+					},
+				},
+			},
+			ExpectedValue: true,
+		},
+		{
+			Name: "No Device Has Label Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdf": {
+						Fs: model.Ext4,
+					},
+				},
+			},
+			ExpectedValue: false,
+		},
+	}
+	for _, subtest := range subtests {
+		t.Run(subtest.Name, func(t *testing.T) {
+			ldl := NewLabelDeviceLayer(nil)
+			value := ldl.ShouldProcess(subtest.Config)
+			utils.CheckOutput("ldl.ShouldProcess()", t, subtest.ExpectedValue, value)
+		})
+	}
+}

internal/layer/layer_test.go

@@ -15,9 +15,10 @@ const (
 )
 
 type MockLayer struct {
-	from     *utils.MockIncrementError
-	modify   *utils.MockIncrementError
-	validate *utils.MockIncrementError
+	from          *utils.MockIncrementError
+	modify        *utils.MockIncrementError
+	validate      *utils.MockIncrementError
+	shouldProcess bool
 }
 
 func (ml *MockLayer) From(c *config.Config) error {
@@ -41,7 +42,7 @@ func (ml *MockLayer) Warning() string {
 }
 
 func (ml *MockLayer) ShouldProcess(c *config.Config) bool {
-	return true
+	return ml.shouldProcess
 }
 
 func TestExponentialBackoffLayerExecutor(t *testing.T) {
@@ -110,13 +111,30 @@ func TestExponentialBackoffLayerExecutor(t *testing.T) {
 	for _, subtest := range subtests {
 		t.Run(subtest.Name, func(t *testing.T) {
 			ml := &MockLayer{
-				from:     subtest.From,
-				modify:   subtest.Modify,
-				validate: subtest.Validate,
+				from:          subtest.From,
+				modify:        subtest.Modify,
+				validate:      subtest.Validate,
+				shouldProcess: true,
 			}
 			eb := NewExponentialBackoffLayerExecutor(nil, mae, ebp)
 			err := eb.Execute([]Layer{ml})
 			utils.CheckError("eb.Execute()", t, subtest.ExpectedError, err)
 		})
 	}
 }
+
+func TestExponentialBackoffLayerExecutorShouldProcess(t *testing.T) {
+	// This MockLayer will fail if any of the From(), Modify() or Validate() methods
+	// are invoked. `shouldProcess` has been set to false so these methods would be skipped
+	// and there should be no error generated
+	ml := &MockLayer{
+		from:          utils.NewMockIncrementError("From()", utils.SuccessUntilTrigger, 1),
+		modify:        utils.NewMockIncrementError("Modidy()", utils.SuccessUntilTrigger, 1),
+		validate:      utils.NewMockIncrementError("Validate()", utils.SuccessUntilTrigger, 1),
+		shouldProcess: false,
+	}
+	debp := DefaultExponentialBackoffParameters()
+	eb := NewExponentialBackoffLayerExecutor(nil, nil, debp)
+	err := eb.Execute([]Layer{ml})
+	utils.CheckError("eb.Execute()", t, nil, err)
+}

internal/layer/lv_activate_test.go

@@ -0,0 +1,45 @@
+package layer
+
+import (
+	"testing"
+
+	"github.com/reecetech/ebs-bootstrap/internal/config"
+	"github.com/reecetech/ebs-bootstrap/internal/utils"
+)
+
+func TestActivateLogicalVolumeLayerShouldProcess(t *testing.T) {
+	subtests := []struct {
+		Name          string
+		Config        *config.Config
+		ExpectedValue bool
+	}{
+		{
+			Name: "At Least Once Device Has Lvm Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdb": {
+						Lvm: "lvm-id",
+					},
+					"/dev/xvdf": {},
+				},
+			},
+			ExpectedValue: true,
+		},
+		{
+			Name: "No Device Has Lvm Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdf": {},
+				},
+			},
+			ExpectedValue: false,
+		},
+	}
+	for _, subtest := range subtests {
+		t.Run(subtest.Name, func(t *testing.T) {
+			alvl := NewActivateLogicalVolumeLayer(nil)
+			output := alvl.ShouldProcess(subtest.Config)
+			utils.CheckOutput("alvl.ShouldProcess()", t, subtest.ExpectedValue, output)
+		})
+	}
+}

internal/layer/lv_resize_test.go

@@ -0,0 +1,59 @@
+package layer
+
+import (
+	"testing"
+
+	"github.com/reecetech/ebs-bootstrap/internal/config"
+	"github.com/reecetech/ebs-bootstrap/internal/utils"
+)
+
+func TestResizeLogicalVolumeLayerShouldProcess(t *testing.T) {
+	subtests := []struct {
+		Name          string
+		Config        *config.Config
+		ExpectedValue bool
+	}{
+		{
+			Name: "At Least Once Device Has Lvm Specified and Resize Enabled",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdb": {
+						Lvm: "lvm-id",
+						Options: config.Options{
+							Resize: true,
+						},
+					},
+					"/dev/xvdf": {},
+				},
+			},
+			ExpectedValue: true,
+		},
+		{
+			Name: "Device Has Lvm Specified, but Resize Disabled",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdb": {
+						Lvm: "lvm-id",
+					},
+				},
+			},
+			ExpectedValue: false,
+		},
+		{
+			Name: "No Device Has Lvm Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdf": {},
+				},
+			},
+			ExpectedValue: false,
+		},
+	}
+	for _, subtest := range subtests {
+		t.Run(subtest.Name, func(t *testing.T) {
+			rlvl := NewResizeLogicalVolumeLayer(nil)
+			output := rlvl.ShouldProcess(subtest.Config)
+			utils.CheckOutput("rlvl.ShouldProcess()", t, subtest.ExpectedValue, output)
+		})
+	}
+}

internal/layer/lv_test.go

@@ -0,0 +1,45 @@
+package layer
+
+import (
+	"testing"
+
+	"github.com/reecetech/ebs-bootstrap/internal/config"
+	"github.com/reecetech/ebs-bootstrap/internal/utils"
+)
+
+func TestCreateLogicalVolumeLayerShouldProcess(t *testing.T) {
+	subtests := []struct {
+		Name          string
+		Config        *config.Config
+		ExpectedValue bool
+	}{
+		{
+			Name: "At Least Once Device Has Lvm Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdb": {
+						Lvm: "lvm-id",
+					},
+					"/dev/xvdf": {},
+				},
+			},
+			ExpectedValue: true,
+		},
+		{
+			Name: "No Device Has Lvm Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdf": {},
+				},
+			},
+			ExpectedValue: false,
+		},
+	}
+	for _, subtest := range subtests {
+		t.Run(subtest.Name, func(t *testing.T) {
+			clvl := NewCreateLogicalVolumeLayer(nil)
+			output := clvl.ShouldProcess(subtest.Config)
+			utils.CheckOutput("clvl.ShouldProcess()", t, subtest.ExpectedValue, output)
+		})
+	}
+}

internal/layer/mount_test.go

@@ -565,3 +565,40 @@ func TestMountDeviceLayerValidate(t *testing.T) {
 		})
 	}
 }
+
+func TestMountDeviceLayerShouldProcess(t *testing.T) {
+	subtests := []struct {
+		Name           string
+		Config         *config.Config
+		ExpectedOutput bool
+	}{
+		{
+			Name: "At Least Once Device Has Mount Point Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdb": {},
+					"/dev/xvdf": {
+						MountPoint: "/mnt/foo",
+					},
+				},
+			},
+			ExpectedOutput: true,
+		},
+		{
+			Name: "No Device Has Mount Point Specified",
+			Config: &config.Config{
+				Devices: map[string]config.Device{
+					"/dev/xvdf": {},
+				},
+			},
+			ExpectedOutput: false,
+		},
+	}
+	for _, subtest := range subtests {
+		t.Run(subtest.Name, func(t *testing.T) {
+			mdl := NewMountDeviceLayer(nil, nil)
+			output := mdl.ShouldProcess(subtest.Config)
+			utils.CheckOutput("mdl.ShouldProcess()", t, subtest.ExpectedOutput, output)
+		})
+	}
+}