Refactor 2

.github/codecov.yml

@@ -0,0 +1,13 @@
+coverage:
+  precision: 2
+  round: nearest
+  range: "70...100"
+  status:
+    project:
+      default:
+        target: auto
+        threshold: 15%
+    patch:
+      default:
+        target: 30%
+        threshold: 30%

.github/workflows/build-and-test.yml

@@ -6,8 +6,6 @@ on:
     tags:
       - v*
   pull_request:
-  pull_request_target:
-    types: [opened, edited]
 
 env:
   GO_VERSION: "~1.20"

README.md

@@ -41,6 +41,7 @@ Spin up your entire dev stack with one command.
     - [Example Configurations](#example-configurations)
   - [Integrations](#integrations)
     - [Integration: dotenv-vault](#integration-dotenv-vault)
+    - [Integration: Infisical](#integration-infisical)
     - [Integration: Telegram Notifications](#integration-telegram-notifications)
     - [Integration: Slack Notifications](#integration-slack-notifications)
     - [Integration: Desktop Notifications](#integration-desktop-notifications)
@@ -499,6 +500,23 @@ env:
   - dotenv://vault # loads .env.vault, if it exists
 ```
 
+### Integration: Infisical
+
+`StackUp` includes an integration for loading secrets from an `Infisical` workspace (see the [Infisical website](https://infisical.com/)).
+
+You must define an environment variable _(either in a `.env` file or manually)_ named `INFISICAL_API_TOKEN` that contains an Infisical project's service token.
+
+The `Infisical` integration supports loading secrets from a workspace, environment, or both.  To load secrets from a workspace (project), add an entry to the `env` section with the value `infisical://workspace-id:environment`.  The `workspace-id` is the id of the workspace to load secrets from, and the `environment` is the name of the environment to load secrets from.
+
+```yaml
+env:
+  - MY_ENV_VAR_ONE=test1234
+  # load all secrets from the Infisical workspace with the id 123425fa2002e3a200d7a300 from the dev environment:
+  - infisical://123425fa2002e3a200d7a300:dev
+```
+
+Note that all secrets the service token has access to will be imported into the environment.
+
 ### Integration: Telegram Notifications
 
 `StackUp` includes an integration for sending notifications via Telegram.  To configure the integration, see the [Telegram Notifications](#configuration-settings-notifications-telegram) section of the [Configuration: Settings](#configuration-settings) documentation.

Taskfile.dist.yaml

@@ -92,11 +92,9 @@ tasks:
       - cp -f ./.env {{.BUILD_OUTPUT_DIR}}
 
   update-checksums:
-    dir: templates/remote-includes
     cmds:
-      - sha256sum *.yaml > checksums.sha256.txt
-      - git add checksums.sha256.txt
-      - git commit -m "update checksum files"
+      - sha256sum ./templates/remote-includes/*.yaml > ./templates/remote-includes/checksums.sha256.txt
+      - sed 's/\.\/templates\/remote-includes\///g' ./templates/remote-includes/checksums.sha256.txt --in-place
 
   autobuild:
     interactive: true

go.mod

@@ -37,6 +37,7 @@ require (
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/rs/xid v1.5.0 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
+	github.com/stretchr/objx v0.5.0 // indirect
 	github.com/tadvi/systray v0.0.0-20190226123456-11a2b8fa57af // indirect
 	github.com/technoweenie/multipartstreamer v1.0.1 // indirect
 	golang.org/x/crypto v0.12.0 // indirect

go.sum

@@ -99,6 +99,7 @@ github.com/slack-go/slack v0.12.3 h1:92/dfFU8Q5XP6Wp5rr5/T5JHLM5c5Smtn53fhToAP88
 github.com/slack-go/slack v0.12.3/go.mod h1:hlGi5oXA+Gt+yWTPP0plCdRKmjsDxecdHxYQdlMQKOw=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=

lib/app/tasks.go

@@ -53,7 +53,7 @@ type ScheduledTask struct {
 	TaskReferenceContract
 }
 
-func (task *Task) canRunOnCurrentPlatform() bool {
+func (task *Task) CanRunOnCurrentPlatform() bool {
 	if task.Platforms == nil || len(task.Platforms) == 0 {
 		return true
 	}
@@ -67,7 +67,7 @@ func (task *Task) canRunOnCurrentPlatform() bool {
 	return false
 }
 
-func (task *Task) canRunConditionally() bool {
+func (task *Task) CanRunConditionally() bool {
 	if len(strings.TrimSpace(task.If)) == 0 {
 		return true
 	}
@@ -163,12 +163,12 @@ func (task *Task) prepareRun() (bool, func()) {
 		task.Path = task.JsEngine.Evaluate(task.Path).(string)
 	}
 
-	if !task.canRunConditionally() {
+	if !task.CanRunConditionally() {
 		support.SkippedMessageWithSymbol(task.GetDisplayName())
 		return false, nil
 	}
 
-	if !task.canRunOnCurrentPlatform() {
+	if !task.CanRunOnCurrentPlatform() {
 		support.SkippedMessageWithSymbol("Task '" + task.GetDisplayName() + "' is not supported on this operating system.")
 		return false, nil
 	}

lib/app/tasks_test.go

@@ -0,0 +1,123 @@
+package app_test
+
+import (
+	"runtime"
+	"testing"
+
+	"github.com/stackup-app/stackup/lib/app"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+type MockJsEngine struct {
+	MockEvaluate func(script string) interface{}
+	mock.Mock
+}
+
+func (m *MockJsEngine) Evaluate(script string) interface{} {
+	return m.MockEvaluate(script)
+}
+
+func TestGetDisplayName(t *testing.T) {
+	assert := assert.New(t)
+
+	// Test case: When Include field has a value with "https://"
+	task1 := app.Task{
+		Include: "https://example.com",
+		Name:    "TestName",
+		Id:      "TestId",
+		Uuid:    "TestUuid",
+	}
+	assert.Equal("example.com", task1.GetDisplayName())
+
+	// Test case: When Include field has a value without "https://"
+	task2 := app.Task{
+		Include: "example.com",
+		Name:    "TestName",
+		Id:      "TestId",
+		Uuid:    "TestUuid",
+	}
+	assert.Equal("example.com", task2.GetDisplayName())
+
+	// Test case: When Name field has a value
+	task3 := app.Task{
+		Name: "TestName",
+		Id:   "TestId",
+		Uuid: "TestUuid",
+	}
+	assert.Equal("TestName", task3.GetDisplayName())
+
+	// Test case: When Id field has a value
+	task4 := app.Task{
+		Id:   "TestId",
+		Uuid: "TestUuid",
+	}
+	assert.Equal("TestId", task4.GetDisplayName())
+
+	// Test case: When only Uuid field has a value
+	task5 := app.Task{
+		Uuid: "TestUuid",
+	}
+	assert.Equal("TestUuid", task5.GetDisplayName())
+
+	// Test case: When no fields have values
+	task6 := app.Task{}
+	assert.Equal("", task6.GetDisplayName())
+}
+
+func TestCanRunOnCurrentPlatform(t *testing.T) {
+	assert := assert.New(t)
+
+	// Test case: When Platforms is nil
+	task1 := &app.Task{}
+	assert.True(task1.CanRunOnCurrentPlatform())
+
+	// Test case: When Platforms is empty
+	task2 := &app.Task{Platforms: []string{}}
+	assert.True(task2.CanRunOnCurrentPlatform())
+
+	// Test case: When Platforms contains the current platform (case insensitive)
+	task3 := &app.Task{Platforms: []string{runtime.GOOS}}
+	assert.True(task3.CanRunOnCurrentPlatform())
+
+	// Test case: When Platforms does not contain the current platform
+	task4 := &app.Task{Platforms: []string{"someotherplatform"}}
+	assert.False(task4.CanRunOnCurrentPlatform())
+}
+
+// func TestCanRunConditionally(t *testing.T) {
+// 	assert := assert.New(t)
+
+// 	// Test case: When If field is empty
+// 	task1 := &app.Task{If: ""}
+// 	assert.True(task1.CanRunConditionally())
+
+// 	// Test case: When JsEngine.Evaluate returns true
+// 	getJsEngine := func(mockEval func(script string) interface{}) interface{} {
+// 		engine := &MockJsEngine{
+// 			MockEvaluate: mockEval,
+// 		}
+
+// 		return engine
+// 	}
+
+// 	jsengine2 := getJsEngine(func(script string) interface{} {
+// 		return true
+// 	})
+
+// 	task2 := &app.Task{
+// 		If:       "{{ some condition }}",
+// 		JsEngine: jsengine2.(*scripting.JavaScriptEngine),
+// 	}
+// 	assert.True(task2.CanRunConditionally())
+
+// 	// Test case: When JsEngine.Evaluate returns false
+// 	jsengine3 := getJsEngine(func(script string) interface{} {
+// 		return false
+// 	})
+// 	task3 := &app.Task{
+// 		If:       "some condition",
+// 		JsEngine: jsengine3.(*scripting.JavaScriptEngine),
+// 	}
+// 	assert.False(task3.CanRunConditionally())
+// }

lib/app/workflow.go

@@ -2,6 +2,7 @@ package app
 
 import (
 	"errors"
+	"fmt"
 	"os"
 	"strings"
 	"sync"
@@ -12,6 +13,7 @@ import (
 	"github.com/stackup-app/stackup/lib/consts"
 	"github.com/stackup-app/stackup/lib/debug"
 	"github.com/stackup-app/stackup/lib/gateway"
+	"github.com/stackup-app/stackup/lib/integrations"
 	"github.com/stackup-app/stackup/lib/messages"
 	"github.com/stackup-app/stackup/lib/scripting"
 	"github.com/stackup-app/stackup/lib/settings"
@@ -40,22 +42,32 @@ type StackupWorkflow struct {
 	Cache          *cache.Cache
 	JsEngine       *scripting.JavaScriptEngine
 	Gateway        *gateway.Gateway
+	Integrations   map[string]integrations.Integration
 	ProcessMap     *sync.Map
 	CommandStartCb types.CommandCallback
 	ExitAppFunc    func()
 	types.AppWorkflowContract
 }
 
 func CreateWorkflow(gw *gateway.Gateway, processMap *sync.Map) *StackupWorkflow {
-	return &StackupWorkflow{
+	result := &StackupWorkflow{
 		Settings:      &settings.Settings{},
 		Preconditions: []*WorkflowPrecondition{},
 		Tasks:         []*Task{},
 		State:         WorkflowState{},
 		Includes:      []WorkflowInclude{},
 		Gateway:       gw,
 		ProcessMap:    processMap,
+		Integrations:  map[string]integrations.Integration{},
 	}
+
+	result.Integrations = integrations.List(result.AsContract)
+
+	return result
+}
+
+func (workflow *StackupWorkflow) AsContract() types.AppWorkflowContract {
+	return workflow
 }
 
 func (workflow *StackupWorkflow) FindTaskById(id string) (any, bool) {
@@ -82,6 +94,10 @@ func (workflow *StackupWorkflow) FindTaskByUuid(uuid string) *Task {
 	return nil
 }
 
+func (workflow *StackupWorkflow) GetEnvSection() []string {
+	return workflow.Env
+}
+
 func (workflow *StackupWorkflow) TryLoadDotEnvVaultFile() {
 	if !utils.ArrayContains(workflow.Env, "dotenv://vault") {
 		return
@@ -109,7 +125,17 @@ func (workflow *StackupWorkflow) Initialize(engine *scripting.JavaScriptEngine,
 	workflow.JsEngine = engine
 
 	utils.ImportEnvDefsIntoEnvironment(workflow.Env)
-	workflow.TryLoadDotEnvVaultFile()
+
+	for _, integration := range workflow.Integrations {
+		if integration.IsEnabled() {
+			err := integration.Run()
+
+			if err != nil {
+				fmt.Printf(" integration error [%s]: %v\n", integration.Name(), err)
+			}
+		}
+	}
+
 	workflow.InitializeSections()
 	workflow.processIncludes()
 }

lib/app/workflow_test.go

@@ -0,0 +1,50 @@
+package app_test
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stackup-app/stackup/lib/app"
+	"github.com/stackup-app/stackup/lib/gateway"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCreateWorkflow(t *testing.T) {
+	gw := &gateway.Gateway{} // Mock or initialize as needed
+	processMap := &sync.Map{}
+	workflow := app.CreateWorkflow(gw, processMap)
+
+	assert.NotNil(t, workflow)
+	assert.NotNil(t, workflow.Settings)
+	assert.NotNil(t, workflow.Preconditions)
+	assert.NotNil(t, workflow.Tasks)
+	assert.NotNil(t, workflow.Includes)
+	assert.NotNil(t, workflow.Gateway)
+	assert.NotNil(t, workflow.ProcessMap)
+	assert.NotNil(t, workflow.Integrations)
+}
+
+func TestAsContract(t *testing.T) {
+	workflow := &app.StackupWorkflow{}
+	contract := workflow.AsContract()
+
+	assert.NotNil(t, contract)
+}
+
+func TestFindTaskById(t *testing.T) {
+	workflow := &app.StackupWorkflow{
+		Tasks: []*app.Task{
+			{Id: "test1"},
+			{Id: "test2"},
+		},
+	}
+
+	taskAny, found := workflow.FindTaskById("test1")
+	var task *app.Task = taskAny.(*app.Task)
+
+	assert.True(t, found)
+	assert.Equal(t, "test1", task.Id)
+
+	_, notFound := workflow.FindTaskById("test3")
+	assert.False(t, notFound)
+}