stoobly-agent 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

stoobly_agent/app/cli/scaffold/workflow_validate_command.py

@@ -0,0 +1,94 @@
+import pdb
+
+from docker import errors as docker_errors
+
+from stoobly_agent.app.cli.scaffold.constants import WORKFLOW_TEST_TYPE
+from stoobly_agent.app.cli.scaffold.managed_services_docker_compose import (
+  ManagedServicesDockerCompose,
+)
+from stoobly_agent.app.cli.scaffold.templates.constants import (
+  CORE_ENTRYPOINT_SERVICE_NAME,
+  CORE_GATEWAY_SERVICE_NAME,
+  CORE_MOCK_UI_SERVICE_NAME,
+  CORE_SERVICES,
+)
+from stoobly_agent.app.cli.scaffold.validate_command import ValidateCommand
+from stoobly_agent.app.cli.scaffold.validate_exceptions import ScaffoldValidateException
+from stoobly_agent.app.cli.scaffold.workflow_command import WorkflowCommand
+
+from .app import App
+
+
+class WorkflowValidateCommand(WorkflowCommand, ValidateCommand):
+  def __init__(self, app: App, **kwargs):
+    WorkflowCommand.__init__(self, app, **kwargs)
+    ValidateCommand.__init__(self)
+    self.managed_services_docker_compose = ManagedServicesDockerCompose(target_workflow_name=self.workflow_name)
+
+  def validate_core_components(self):
+    print(f"Validating core component: {CORE_GATEWAY_SERVICE_NAME}")
+    gateway_container_name = self.managed_services_docker_compose.gateway_container_name
+    gateway_container = self.docker_client.containers.get(gateway_container_name)
+    if not gateway_container or (gateway_container.status != 'running'):
+      raise ScaffoldValidateException(f"Container '{gateway_container_name}' not found for service '{CORE_GATEWAY_SERVICE_NAME}'")
+
+    print(f"Validating core component: {CORE_MOCK_UI_SERVICE_NAME}")
+    mock_ui_container_name = self.managed_services_docker_compose.mock_ui_container_name
+    mock_ui_container = self.docker_client.containers.get(mock_ui_container_name)
+    if not mock_ui_container or (mock_ui_container.status != 'running'):
+      raise ScaffoldValidateException(f"Container '{mock_ui_container_name}' not found for service '{CORE_MOCK_UI_SERVICE_NAME}'")
+
+  def validate_no_core_components(self):
+    try:
+      core_gateway_container = self.docker_client.containers.get(self.managed_services_docker_compose.gateway_container_name)
+      if core_gateway_container:
+        raise ScaffoldValidateException(f"Gateway container is running when it shouldn't: {core_gateway_container.name}")
+    except docker_errors.NotFound:
+      pass
+    
+    try:
+      core_mock_ui_container_name = self.docker_client.containers.get(self.managed_services_docker_compose.mock_ui_container_name)
+      if core_mock_ui_container_name:
+        raise ScaffoldValidateException(f"Stoobly UI container is running when it shouldn't: {core_mock_ui_container_name.name}")
+    except docker_errors.NotFound:
+      pass
+    
+    print(f"Skipping validating core component: {CORE_GATEWAY_SERVICE_NAME}")
+    print(f"Skipping validating core component: {CORE_MOCK_UI_SERVICE_NAME}")
+
+  
+  def validate(self) -> bool:
+    print(f"Validating workflow: {self.workflow_name}")
+    print(f"Validating core components: {CORE_SERVICES}")
+
+    if self.workflow_name == WORKFLOW_TEST_TYPE:
+      # Don't validate the gateway and mock_ui core components in the "test" workflow 
+      self.validate_no_core_components()
+    else:
+      self.validate_core_components()
+
+    self.validate_init_containers(self.managed_services_docker_compose.init_container_name, self.managed_services_docker_compose.configure_container_name)
+
+    print(f"Validating core component: {CORE_ENTRYPOINT_SERVICE_NAME}")
+
+    try:
+      core_entrypoint_init_container_name = self.managed_services_docker_compose.entrypoint_init_container_name
+      entrypoint_init_container = self.docker_client.containers.get(core_entrypoint_init_container_name)
+    except docker_errors.NotFound:
+      raise ScaffoldValidateException(f"Container not found: {core_entrypoint_init_container_name}")
+
+    try:
+      core_entrypoint_configure_container_name = self.managed_services_docker_compose.entrypoint_configure_container_name
+      entrypoint_configure_container = self.docker_client.containers.get(core_entrypoint_configure_container_name)
+    except docker_errors.NotFound:
+      raise ScaffoldValidateException(f"Container not found: {core_entrypoint_configure_container_name}")
+
+    # NOTE: we should check the correct workflow mode is enabled one day
+    # That's not currently queryable
+
+    print(f"Done validating workflow: {self.workflow_name}, success!")
+    print()
+
+    return True
+
+

stoobly_agent/app/cli/scaffold_cli.py

@@ -9,6 +9,7 @@ from stoobly_agent.app.cli.helpers.certificate_authority import CertificateAutho
 from stoobly_agent.app.cli.helpers.shell import exec_stream
 from stoobly_agent.app.cli.scaffold.app import App
 from stoobly_agent.app.cli.scaffold.app_create_command import AppCreateCommand
+from stoobly_agent.app.cli.scaffold.constants import DOCKER_NAMESPACE, WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE
 from stoobly_agent.app.cli.scaffold.constants import (
   DOCKER_NAMESPACE, WORKFLOW_CUSTOM_FILTER, WORKFLOW_MOCK_TYPE, WORKFLOW_RECORD_TYPE, WORKFLOW_TEST_TYPE
 )
@@ -17,12 +18,15 @@ from stoobly_agent.app.cli.scaffold.docker.workflow.decorators_factory import ge
 from stoobly_agent.app.cli.scaffold.service import Service
 from stoobly_agent.app.cli.scaffold.service_config import ServiceConfig
 from stoobly_agent.app.cli.scaffold.service_create_command import ServiceCreateCommand
+from stoobly_agent.app.cli.scaffold.service_workflow_validate_command import ServiceWorkflowValidateCommand
 from stoobly_agent.app.cli.scaffold.templates.constants import CORE_SERVICES
+from stoobly_agent.app.cli.scaffold.validate_exceptions import ScaffoldValidateException
 from stoobly_agent.app.cli.scaffold.workflow import Workflow
 from stoobly_agent.app.cli.scaffold.workflow_create_command import WorkflowCreateCommand
 from stoobly_agent.app.cli.scaffold.workflow_copy_command import WorkflowCopyCommand
 from stoobly_agent.app.cli.scaffold.workflow_log_command import WorkflowLogCommand
 from stoobly_agent.app.cli.scaffold.workflow_run_command import WorkflowRunCommand
+from stoobly_agent.app.cli.scaffold.workflow_validate_command import WorkflowValidateCommand
 from stoobly_agent.config.constants import env_vars
 from stoobly_agent.config.data_dir import DataDir
 from stoobly_agent.lib.logger import bcolors, DEBUG, ERROR, INFO, Logger, WARNING
@@ -312,18 +316,23 @@ def logs(**kwargs):
 @click.option('--ca-certs-dir-path', default=DataDir.instance().mitmproxy_conf_dir_path, help='Path to ca certs directory used to sign SSL certs. Defaults to ~/.mitmproxy')
 @click.option('--certs-dir-path', help='Path to certs directory. Defaults to the certs dir of the context.')
 @click.option('--context-dir-path', default=DataDir.instance().context_dir_path, help='Path to Stoobly data directory.')
+@click.option('--detached', is_flag=True, help='If set, will not run the highest priority service in the foreground.')
 @click.option('--filter', multiple=True, type=click.Choice([WORKFLOW_CUSTOM_FILTER]), help='Select which service groups to run. Defaults to all.')
 @click.option('--dry-run', default=False, is_flag=True, help='If set, prints commands.')
 @click.option('--extra-compose-path', help='Path to extra compose configuration files.')
 @click.option('--log-level', default=INFO, type=click.Choice([DEBUG, INFO, WARNING, ERROR]), help='''
     Log levels can be "debug", "info", "warning", or "error"
 ''')
-@click.option('--network', help='Name of network namespace.')
+@click.option('--namespace', help='Workflow namespace.')
+@click.option('--network', help='Workflow network namespace.')
 @click.option('--service', multiple=True, help='Select which services to run. Defaults to all.')
 @click.argument('workflow_name')
 def run(**kwargs):
   cwd = os.getcwd()
 
+  # Create the certs_dir_path if it doesn't exist
+  DataDir.instance().certs_dir_path
+
   if not os.getenv(env_vars.LOG_LEVEL):
     os.environ[env_vars.LOG_LEVEL] = kwargs['log_level']
 
@@ -365,10 +374,13 @@ def run(**kwargs):
       print(create_network_command)
 
   commands = sorted(commands, key=lambda command: command.service_config.priority)
-  for command in commands:
+  for index, command in enumerate(commands):
     __print_header(f"SERVICE {command.service_name}")
 
-    exec_command = command.up()
+    # By default, the entrypoint service should be last
+    # However, this can change if the user has configured a service's priority to be higher
+    attached = not kwargs['detached'] and index == len(commands) - 1
+    exec_command = command.up(attached=attached, namespace=kwargs['namespace'])
     if not exec_command:
       continue
 
@@ -376,7 +388,37 @@ def run(**kwargs):
       exec_stream(exec_command)
     else:
       print(exec_command)
- 
+
+@workflow.command(
+  help="Validate a scaffold workflow"
+)
+@click.option('--app-dir-path', default=os.getcwd(), help='Path to validate the app scaffold.')
+@click.argument('workflow_name')
+def validate(**kwargs):
+  app = App(kwargs['app_dir_path'], DOCKER_NAMESPACE)
+  workflow = Workflow(kwargs['workflow_name'], app)
+  
+  config = { **kwargs }
+  config['service_name'] = 'build'
+
+  try:
+    command = WorkflowValidateCommand(app, **config)
+    command.validate()
+  except ScaffoldValidateException as sve:
+    print(f"\nFatal Scaffold Validation Exception: {sve}", file=sys.stderr)
+    sys.exit(1)
+
+  try:
+    for service in workflow.services_ran:
+      if service not in CORE_SERVICES:
+        config['service_name'] = service
+        command = ServiceWorkflowValidateCommand(app, **config)
+        command.validate()
+  except ScaffoldValidateException as sve:
+    print(f"\nFatal Scaffold Validation Exception: {sve}", file=sys.stderr)
+    sys.exit(1)
+
+
 scaffold.add_command(app)
 scaffold.add_command(service)
 scaffold.add_command(workflow)
@@ -431,4 +473,5 @@ def __workflow_build(app, **kwargs):
     headless=kwargs['headless'],
     template=kwargs['template'],
     workflow_decorators=workflow_decorators
-  )
+  )
+

stoobly_agent/config/data_dir.py

@@ -1,3 +1,4 @@
+import pdb
 import os
 import shutil
 
@@ -16,6 +17,8 @@ class DataDir:
         if DataDir._instances.get(path):
             raise RuntimeError('Call instance() instead')
         else:
+            self.__path = path
+
             if path:
                 self.__data_dir_path = os.path.join(path, DATA_DIR_NAME)
             else:
@@ -35,6 +38,9 @@ class DataDir:
             if not os.path.exists(self.__data_dir_path):
                 self.create(os.path.dirname(self.__data_dir_path))
 
+    def __repr__(self) -> str:
+      return self.path
+
     @classmethod
     def instance(cls, path: str = None):
         if not cls._instances:
@@ -58,7 +64,7 @@ class DataDir:
 
     @property
     def path(self):
-        if os.environ.get(ENV) == 'test':
+        if not self.__path and os.environ.get(ENV) == 'test':
             test_path = os.path.join(self.__data_dir_path, 'tmp', DATA_DIR_NAME)
 
             if not os.path.exists(test_path):
@@ -212,12 +218,15 @@ class DataDir:
         if not os.path.exists(self.__data_dir_path):
             os.mkdir(self.__data_dir_path)
 
+            # Create the certs_dir_path if it doesn't exist
+            self.certs_dir_path
             # Create tmp folder
-            os.mkdir(os.path.join(self.__data_dir_path, 'tmp'))
+            os.makedirs(os.path.join(self.__data_dir_path, 'tmp'), exist_ok=True)
 
             with open(os.path.join(self.__data_dir_path, '.gitignore'), 'w') as fp:
                 fp.write(
                     "\n".join([
+                        'certs',
                         'db',
                         'settings.yml',
                         os.path.join('snapshots', 'log'),

stoobly_agent/test/app/cli/scaffold/e2e_test.py

@@ -0,0 +1,428 @@
+from pathlib import Path
+import pathlib
+import pdb
+import shutil
+
+from click.testing import CliRunner
+import docker
+import pytest
+
+from stoobly_agent.app.cli import scaffold
+from stoobly_agent.app.cli.scaffold.app import App
+from stoobly_agent.app.cli.scaffold.constants import (
+  WORKFLOW_RECORD_TYPE,
+  WORKFLOW_TEST_TYPE,
+)
+from stoobly_agent.app.cli.scaffold.constants import DOCKER_NAMESPACE
+from stoobly_agent.app.cli.scaffold.managed_services_docker_compose import (
+  ManagedServicesDockerCompose,
+)
+from stoobly_agent.app.cli.scaffold.service_docker_compose import ServiceDockerCompose
+from stoobly_agent.app.cli.scaffold.service_workflow_validate_command import (
+  ServiceWorkflowValidateCommand,
+)
+from stoobly_agent.app.cli.scaffold.workflow_validate_command import (
+  WorkflowValidateCommand,
+)
+from stoobly_agent.config.data_dir import DATA_DIR_NAME, DataDir
+from stoobly_agent.test.test_helper import reset
+
+
+@pytest.mark.e2e
+class TestScaffoldE2e():
+
+  @pytest.fixture(scope='module', autouse=True)
+  def settings(self):
+    return reset()
+
+  @pytest.fixture(scope='module')
+  def runner(self):
+    yield CliRunner()
+
+  @pytest.fixture(scope='class')
+  def docker_client(self):
+    yield docker.from_env()
+
+  @pytest.fixture(scope='class')
+  def app_name(self):
+    yield "0.0.1"
+
+  @pytest.fixture(scope='class', autouse=True)
+  def temp_dir(self):
+    data_dir_path = DataDir.instance().path
+    tmp_path = data_dir_path[:data_dir_path.rfind('/')]
+
+    yield tmp_path
+
+  @pytest.fixture(scope='class', autouse=True)
+  def app_dir_path(self, temp_dir, app_name):
+    yield temp_dir
+
+  @pytest.fixture(scope='class')
+  def mock_data_directory_path(self):
+    yield Path(__file__).parent.parent.parent.parent / 'mock_data'
+  
+  @pytest.fixture(scope='class')
+  def local_service_mock_docker_compose_path(self, mock_data_directory_path):
+    path = mock_data_directory_path / "scaffold" / "docker-compose-local-service.yml"
+    yield path
+
+  @pytest.fixture(scope='class')
+  def hostname(self):
+    yield "http.badssl.com"
+
+  @pytest.fixture(scope='class')
+  def https_service_hostname(self):
+    yield "example.com"
+  
+  @pytest.fixture(scope='class')
+  def external_service_name(self):
+    yield "external-service"
+
+  @pytest.fixture(scope='class')
+  def external_https_service_name(self):
+    yield "external-https-service"
+
+  @pytest.fixture(scope='class')
+  def local_hostname(self):
+    yield "my-httpbin.com"
+
+  @pytest.fixture(scope='class')
+  def local_service_name(self):
+    yield "my-httpbin"
+
+  
+  class TestRecordWorkflow():
+    @pytest.fixture(scope='class', autouse=True)
+    def target_workflow_name(self):
+      yield WORKFLOW_RECORD_TYPE
+
+    @pytest.fixture(scope='class')
+    def managed_services_docker_compose(self, target_workflow_name):
+      yield ManagedServicesDockerCompose(target_workflow_name=target_workflow_name)
+
+    @pytest.fixture(scope='class')
+    def external_service_docker_compose(self, app_dir_path, target_workflow_name, external_service_name, hostname):
+      yield ServiceDockerCompose(app_dir_path=app_dir_path, target_workflow_name=target_workflow_name, service_name=external_service_name, hostname=hostname)
+    
+    @pytest.fixture(scope='class')
+    def external_https_service_docker_compose(self, app_dir_path, target_workflow_name, external_https_service_name, https_service_hostname):
+      yield ServiceDockerCompose(app_dir_path=app_dir_path, target_workflow_name=target_workflow_name, service_name=external_https_service_name, hostname=https_service_hostname)
+
+    @pytest.fixture(scope='class')
+    def local_service_docker_compose(self, app_dir_path, target_workflow_name, local_service_name, local_hostname):
+      yield ServiceDockerCompose(app_dir_path=app_dir_path, target_workflow_name=target_workflow_name, service_name=local_service_name, hostname=local_hostname)
+
+    @pytest.fixture(scope='class', autouse=True)
+    def setup_docker_composes(self, managed_services_docker_compose, external_service_docker_compose, local_service_docker_compose):
+      self.managed_services_docker_compose = managed_services_docker_compose
+      self.external_service_docker_compose = external_service_docker_compose
+      self.local_service_docker_compose = local_service_docker_compose
+
+    @pytest.fixture(scope="class", autouse=True)
+    def create_scaffold_setup(self, runner, app_dir_path, app_name, target_workflow_name, external_service_docker_compose, external_https_service_docker_compose, local_service_docker_compose, local_service_mock_docker_compose_path):
+      TestScaffoldE2e.cli_app_create(runner, app_dir_path, app_name)
+
+      # Create external user defined service
+      TestScaffoldE2e.cli_service_create(runner, app_dir_path, external_service_docker_compose.hostname, external_service_docker_compose.service_name, False)
+      TestScaffoldE2e.cli_service_create(runner, app_dir_path, external_https_service_docker_compose.hostname, external_https_service_docker_compose.service_name, True)
+
+      # Create local user defined service
+      TestScaffoldE2e.cli_service_create(runner, app_dir_path, local_service_docker_compose.hostname, local_service_docker_compose.service_name, False)
+
+      # Validate docker-compose path exists
+      destination_path = Path(local_service_docker_compose.docker_compose_path)
+      assert destination_path.is_file()
+      # Add user defined Docker Compose file for the local service
+      shutil.copyfile(local_service_mock_docker_compose_path, destination_path)
+
+      # Record workflow doesn't have a fixtures folder
+
+      # Generate certs
+      TestScaffoldE2e.cli_app_mkcert(runner, app_dir_path)
+
+      TestScaffoldE2e.cli_workflow_run(runner, app_dir_path, target_workflow_name)
+
+    @pytest.fixture(scope="class", autouse=True)
+    def cleanup_after_all(self, runner, app_dir_path, target_workflow_name):
+      yield
+      TestScaffoldE2e.cli_workflow_stop(runner, app_dir_path, target_workflow_name)
+
+    def test_core_components(self, app_dir_path, target_workflow_name):
+      app = App(app_dir_path, DOCKER_NAMESPACE)
+      config = {
+        'workflow_name': target_workflow_name,
+        'service_name': 'build'
+      }
+
+      command = WorkflowValidateCommand(app, **config)
+      command.validate()
+
+    def test_external_service(self, external_service_docker_compose: ServiceDockerCompose, app_dir_path, target_workflow_name):
+      app = App(app_dir_path, DOCKER_NAMESPACE)
+      config = {
+        'workflow_name': target_workflow_name,
+        'service_name': external_service_docker_compose.service_name 
+      }
+
+      command = ServiceWorkflowValidateCommand(app, **config)
+      command.validate()
+
+    def test_local_service(self, app_dir_path, target_workflow_name, local_service_docker_compose: ServiceDockerCompose):
+      app = App(app_dir_path, DOCKER_NAMESPACE)
+      config = {
+        'workflow_name': target_workflow_name,
+        'service_name': local_service_docker_compose.service_name 
+      }
+
+      command = ServiceWorkflowValidateCommand(app, **config)
+      command.validate()
+
+
+  class TestTestWorkflow():
+    @pytest.fixture(scope='class')
+    def assets_service_mock_docker_compose_path(self, mock_data_directory_path):
+      path = mock_data_directory_path / "scaffold" / "docker-compose-assets-service.yml"
+      yield path
+
+    @pytest.fixture(scope='class')
+    def assets_service_assets_path(self, mock_data_directory_path):
+      path = mock_data_directory_path / "scaffold" / "index.html"
+      yield path
+    
+    @pytest.fixture(scope='class', autouse=True)
+    def target_workflow_name(self):
+      yield WORKFLOW_TEST_TYPE
+
+    @pytest.fixture(scope='class')
+    def assets_service_name(self):
+      yield "assets"
+    
+    @pytest.fixture(scope='class')
+    def assets_hostname(self):
+      yield "assets"
+
+    @pytest.fixture(scope='class')
+    def managed_services_docker_compose(self, target_workflow_name):
+      yield ManagedServicesDockerCompose(target_workflow_name=target_workflow_name)
+    
+    @pytest.fixture(scope='class')
+    def external_service_docker_compose(self, app_dir_path, target_workflow_name, external_service_name, hostname):
+      yield ServiceDockerCompose(app_dir_path=app_dir_path, target_workflow_name=target_workflow_name, service_name=external_service_name, hostname=hostname)
+
+    @pytest.fixture(scope='class')
+    def local_service_docker_compose(self, app_dir_path, target_workflow_name, local_service_name, local_hostname):
+      yield ServiceDockerCompose(app_dir_path=app_dir_path, target_workflow_name=target_workflow_name, service_name=local_service_name, hostname=local_hostname)
+    
+    @pytest.fixture(scope='class')
+    def assets_service_docker_compose(self, app_dir_path, target_workflow_name, assets_service_name, assets_hostname):
+      yield ServiceDockerCompose(app_dir_path=app_dir_path, target_workflow_name=target_workflow_name, service_name=assets_service_name, hostname=assets_hostname)
+
+    @pytest.fixture(scope='class', autouse=True)
+    def setup_docker_composes(self, managed_services_docker_compose, external_service_docker_compose, local_service_docker_compose, assets_service_docker_compose):
+      self.managed_services_docker_compose = managed_services_docker_compose
+      self.external_service_docker_compose = external_service_docker_compose
+      self.local_service_docker_compose = local_service_docker_compose
+      self.assets_service_docker_compose = assets_service_docker_compose
+
+    @pytest.fixture(scope="class", autouse=True)
+    def create_scaffold_setup(self, runner, app_name, app_dir_path, target_workflow_name, external_service_docker_compose, local_service_docker_compose, assets_service_docker_compose, mock_data_directory_path, assets_service_mock_docker_compose_path):
+
+      TestScaffoldE2e.cli_app_create(runner, app_dir_path, app_name)
+
+      # Create external user defined service
+      TestScaffoldE2e.cli_service_create(runner, app_dir_path, external_service_docker_compose.hostname, external_service_docker_compose.service_name, False)
+      # Create local user defined services
+      TestScaffoldE2e.cli_service_create(runner, app_dir_path, local_service_docker_compose.hostname, local_service_docker_compose.service_name, False)
+      TestScaffoldE2e.cli_service_create_assets(runner, app_dir_path, assets_service_docker_compose.hostname, assets_service_docker_compose.service_name, False)
+
+      # Don't run the local user defined service in the 'test' workflow
+      # So don't copy the Docker Compose file over
+
+      # Add user defined Docker Compose file for the assets service
+      destination_path = Path(assets_service_docker_compose.docker_compose_path)
+      assert destination_path.is_file()
+      shutil.copyfile(assets_service_mock_docker_compose_path, destination_path)
+
+      TestScaffoldE2e.cli_service_create_assets(runner, app_dir_path, assets_service_docker_compose.hostname, assets_service_docker_compose.service_name, False)
+
+      # Add assets for assets service
+      data_dir_path = DataDir.instance().path
+      destination_assets_path = f"{data_dir_path}/docker/{assets_service_docker_compose.service_name}/{target_workflow_name}/index.html"
+      destination_path = Path(destination_assets_path)
+      assets_mock_path = mock_data_directory_path / "scaffold" / "index.html"
+      shutil.copyfile(assets_mock_path, destination_path)
+
+      # Created shared file in fixtures folder
+      app = App(app_dir_path, DOCKER_NAMESPACE)
+      config = {
+        'workflow_name': target_workflow_name,
+        'service_name': external_service_docker_compose.service_name 
+      }
+      command = ServiceWorkflowValidateCommand(app, **config)
+      with open(f"{command.fixtures_dir_path}/shared_file.txt", 'w') as file:
+        file.write('this is a shared file')
+
+      TestScaffoldE2e.cli_workflow_run(runner, app_dir_path, target_workflow_name=target_workflow_name)
+    
+    @pytest.fixture(scope="class", autouse=True)
+    def cleanup_after_all(self, runner, app_dir_path, target_workflow_name):
+      yield
+      TestScaffoldE2e.cli_workflow_stop(runner, app_dir_path, target_workflow_name)
+
+    def test_no_core_components(self, app_dir_path, target_workflow_name):
+      app = App(app_dir_path, DOCKER_NAMESPACE)
+      config = {
+        'workflow_name': target_workflow_name,
+        'service_name': 'build'
+      }
+
+      command = WorkflowValidateCommand(app, **config)
+      command.validate()
+
+    def test_user_services(self, app_dir_path, target_workflow_name, external_service_docker_compose, local_service_docker_compose):
+      app = App(app_dir_path, DOCKER_NAMESPACE)
+
+      config = {
+        'workflow_name': target_workflow_name,
+        'service_name': external_service_docker_compose.service_name 
+      }
+      command = ServiceWorkflowValidateCommand(app, **config)
+      command.validate()
+
+      config = {
+        'workflow_name': target_workflow_name,
+        'service_name': local_service_docker_compose.service_name 
+      }
+      command = ServiceWorkflowValidateCommand(app, **config)
+      command.validate()
+
+    def test_tests(self):
+      # This is covered by test_assets
+      pass
+
+    def test_assets(self, app_dir_path, target_workflow_name):
+
+      app = App(app_dir_path, DOCKER_NAMESPACE)
+      config = {
+        'workflow_name': target_workflow_name,
+        'service_name': 'assets'
+      }
+
+      command = ServiceWorkflowValidateCommand(app, **config)
+      command.validate()
+
+  @staticmethod
+  def cli_app_create(runner: CliRunner, app_dir_path: str, app_name: str):
+    pathlib.Path(f"{app_dir_path}/{DATA_DIR_NAME}").mkdir(parents=True, exist_ok=True)
+
+    result = runner.invoke(scaffold, ['app', 'create',
+      '--app-dir-path', app_dir_path,
+      '--force',
+      app_name
+    ])
+
+    assert result.exit_code == 0
+    output = result.stdout
+    assert not output
+
+  @staticmethod
+  def cli_app_mkcert(runner: CliRunner, app_dir_path: str):
+    result = runner.invoke(scaffold, ['app', 'mkcert',
+      '--app-dir-path', app_dir_path,
+      '--context-dir-path', app_dir_path,
+    ])
+
+    assert result.exit_code == 0
+    output = result.stdout
+    assert not output
+
+
+  @staticmethod
+  def cli_service_create(runner: CliRunner, app_dir_path: str, hostname: str, service_name: str, https: bool):
+    scheme = 'http'
+    port = '80'
+    if https == True:
+      scheme = 'https'
+      port = '443'
+
+    result = runner.invoke(scaffold, ['service', 'create',
+      '--app-dir-path', app_dir_path,
+      '--env', 'TEST',
+      '--force',
+      '--hostname', hostname,
+      '--scheme', scheme,
+      '--port', port,
+      '--workflow', 'mock',
+      '--workflow', 'record',
+      '--workflow', 'test',
+      service_name
+    ])
+    assert result.exit_code == 0
+    output = result.stdout
+    assert not output
+ 
+  # Specific flags for assets
+  @staticmethod
+  def cli_service_create_assets(runner: CliRunner, app_dir_path: str, hostname: str, service_name: str, https: bool):
+    scheme = 'http'
+    port = '80'
+    if https == True:
+      scheme = 'https'
+      port = '443'
+    proxy_mode_reverse_spec = f"reverse:{scheme}://{hostname}:8080"
+
+    result = runner.invoke(scaffold, ['service', 'create',
+      '--app-dir-path', app_dir_path,
+      '--force',
+      '--hostname', hostname,
+      '--scheme', scheme,
+      '--port', port,
+      '--proxy-mode', proxy_mode_reverse_spec,
+      '--detached',
+      '--workflow', 'test',
+      service_name
+    ])
+    assert result.exit_code == 0
+    output = result.stdout
+    assert not output
+  
+  @staticmethod
+  def cli_workflow_create(runner: CliRunner, app_dir_path: str, service_name: str):
+    result = runner.invoke(scaffold, ['workflow', 'create',
+      '--app-dir-path', app_dir_path,
+      '--service', service_name,
+      '--template', 'mock',
+      'ci',
+    ])
+
+    assert result.exit_code == 0
+    output = result.stdout
+    assert not output
+
+  @staticmethod
+  def cli_workflow_run(runner: CliRunner, app_dir_path: str, target_workflow_name: str):
+    command = ['workflow', 'run',
+      '--app-dir-path', app_dir_path,
+      '--context-dir-path', app_dir_path,
+      target_workflow_name,
+    ]
+    result = runner.invoke(scaffold, command)
+
+    assert result.exit_code == 0
+    output = result.stdout
+    assert output
+  
+  @staticmethod
+  def cli_workflow_stop(runner: CliRunner, app_dir_path: str, target_workflow_name: str):
+    command = ['workflow', 'stop',
+      '--app-dir-path', app_dir_path,
+      '--context-dir-path', app_dir_path,
+      target_workflow_name,
+    ]
+    result = runner.invoke(scaffold, command)
+
+    assert result.exit_code == 0
+    output = result.stdout
+    assert output
+

stoobly_agent/test/app/models/schemas/.stoobly/db/VERSION

@@ -1 +1 @@
-1.0.5
+1.0.7