stoobly-agent 1.9.12__py3-none-any.whl → 1.10.1__py3-none-any.whl

stoobly_agent/test/app/cli/intercept/intercept_configure_test.py

@@ -7,8 +7,10 @@ from stoobly_agent.test.test_helper import reset
 
 from stoobly_agent.cli import config, intercept, scenario
 from stoobly_agent.lib.orm.scenario import Scenario
+from stoobly_agent.app.settings import Settings
+from stoobly_agent.lib.api.keys.project_key import ProjectKey
 
-from stoobly_agent.config.constants import mode, record_order
+from stoobly_agent.config.constants import mode, mock_policy, record_order, record_policy, record_strategy, replay_policy, test_strategy
 
 @pytest.fixture(scope='module')
 def runner():
@@ -51,3 +53,231 @@ class TestInterceptConfigure():
           assert configure_result.exit_code == 0
 
           assert not Scenario.find(scenario.id).overwritable
+
+  class TestPolicy():
+
+    class TestMockPolicy():
+
+      def test_policy_mock_mode_all(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--policy', mock_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.mock_policy == mock_policy.ALL
+
+      def test_policy_mock_mode_found(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--policy', mock_policy.FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.mock_policy == mock_policy.FOUND
+
+      def test_policy_without_mode_mock_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.MOCK])
+        configure_result = runner.invoke(intercept, ['configure', '--policy', mock_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.mock_policy == mock_policy.ALL
+
+    class TestRecordPolicy():
+
+      def test_policy_record_mode_all(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--policy', record_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.ALL
+
+      def test_policy_record_mode_api(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--policy', record_policy.API])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.API
+
+      def test_policy_record_mode_found(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--policy', record_policy.FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.FOUND
+
+      def test_policy_record_mode_not_found(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--policy', record_policy.NOT_FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.NOT_FOUND
+
+      def test_policy_without_mode_record_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.RECORD])
+        configure_result = runner.invoke(intercept, ['configure', '--policy', record_policy.API])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_policy == record_policy.API
+
+    class TestReplayPolicy():
+
+      def test_policy_replay_mode_all(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.REPLAY, '--policy', replay_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.replay_policy == replay_policy.ALL
+
+      def test_policy_without_mode_replay_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.REPLAY])
+        configure_result = runner.invoke(intercept, ['configure', '--policy', replay_policy.ALL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.replay_policy == replay_policy.ALL
+
+    class TestTestPolicy():
+
+      def test_policy_test_mode_found(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.TEST, '--policy', mock_policy.FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_policy == mock_policy.FOUND
+
+      def test_policy_without_mode_test_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.TEST])
+        configure_result = runner.invoke(intercept, ['configure', '--policy', mock_policy.FOUND])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_policy == mock_policy.FOUND
+
+    class TestInvalidPolicyInput():
+      # Since all modes use 'all', we need to check what's unique to each mode
+
+      def test_policy_invalid_for_mock_mode(self, runner: CliRunner):
+        # Use record_policy.API which is not valid for MOCK mode
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--policy', record_policy.API])
+        assert configure_result.exit_code == 1
+        assert "Error: Valid policies for" in configure_result.output
+
+      def test_policy_invalid_for_record_mode(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--policy', record_policy.NOT_FOUND])
+        assert configure_result.exit_code == 1
+        assert "Error: Valid policies for" in configure_result.output
+
+      def test_policy_invalid_for_replay_mode(self, runner: CliRunner):
+        # Use record_policy.API which is not valid for REPLAY mode
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.REPLAY, '--policy', record_policy.API])
+        assert configure_result.exit_code == 1
+        assert "Error: Valid policies for" in configure_result.output
+
+      def test_policy_invalid_for_test_mode(self, runner: CliRunner):
+        # Use record_policy.API which is not valid for TEST mode
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.TEST, '--policy', record_policy.API])
+        assert configure_result.exit_code == 1
+        assert "Error: Valid policies for" in configure_result.output
+
+  class TestStrategy():
+
+    class TestRecordStrategy():
+
+      def test_strategy_record_mode_full(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--strategy', record_strategy.FULL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_strategy == record_strategy.FULL
+
+      def test_strategy_record_mode_minimal(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.RECORD, '--strategy', record_strategy.MINIMAL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_strategy == record_strategy.MINIMAL
+
+      def test_strategy_without_mode_record_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.RECORD])
+        configure_result = runner.invoke(intercept, ['configure', '--strategy', record_strategy.MINIMAL])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.record_strategy == record_strategy.MINIMAL
+
+    @pytest.mark.skip(reason="Switching modes during tests is finnicky and leads to test failures")
+    class TestTestStrategy():
+
+      def test_strategy_test_mode_contract(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.TEST, '--strategy', test_strategy.CONTRACT])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_strategy == test_strategy.CONTRACT
+
+      def test_strategy_test_mode_diff(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.TEST, '--strategy', test_strategy.DIFF])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_strategy == test_strategy.DIFF
+
+      def test_strategy_without_mode_test_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.TEST])
+        configure_result = runner.invoke(intercept, ['configure', '--strategy', test_strategy.FUZZY])
+        assert configure_result.exit_code == 0
+
+        settings = Settings.instance()
+        project_key = ProjectKey(settings.proxy.intercept.project_key)
+        data_rule = settings.proxy.data.data_rules(project_key.id)
+        assert data_rule.test_strategy == test_strategy.FUZZY
+
+    class TestInvalidInput():
+      def test_strategy_mock_mode_error(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.MOCK, '--strategy', record_strategy.FULL])
+        assert configure_result.exit_code == 1
+        assert "Error: set --strategy to a intercept mode that supports the strategy option" in configure_result.output
+
+      def test_strategy_replay_mode_error(self, runner: CliRunner):
+        configure_result = runner.invoke(intercept, ['configure', '--mode', mode.REPLAY, '--strategy', record_strategy.FULL])
+        assert configure_result.exit_code == 1
+        assert "Error: set --strategy to a intercept mode that supports the strategy option" in configure_result.output
+
+      def test_strategy_without_mode_unsupported_existing(self, runner: CliRunner):
+        runner.invoke(intercept, ['configure', '--mode', mode.MOCK])
+        configure_result = runner.invoke(intercept, ['configure', '--strategy', record_strategy.FULL])
+        assert configure_result.exit_code == 1
+        assert "Error: set --strategy to a intercept mode that supports the strategy option" in configure_result.output

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

@@ -66,14 +66,15 @@ class ScaffoldCliInvoker():
     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,
       '--hostname', hostname,
       '--scheme', scheme,
       '--port', port,
-      '--proxy-mode', proxy_mode_reverse_spec,
+      '--upstream-hostname', hostname,
+      '--upstream-port', 80,
+      '--upstream-scheme', 'http',
       '--detached',
       '--quiet',
       '--workflow', 'test',

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

@@ -7,7 +7,7 @@ import pytest
 
 from stoobly_agent.app.cli.scaffold.app import App
 from stoobly_agent.app.cli.scaffold.constants import (
-  DOCKER_NAMESPACE,
+  SERVICES_NAMESPACE,
   WORKFLOW_RECORD_TYPE,
 )
 from stoobly_agent.app.cli.scaffold.service_docker_compose import ServiceDockerCompose
@@ -90,7 +90,7 @@ class TestScaffoldCli():
     
  
     def test_service_delete(self, runner, app_dir_path, external_service_docker_compose):
-      app = App(app_dir_path, DOCKER_NAMESPACE)
+      app = App(app_dir_path, SERVICES_NAMESPACE)
       service_name = external_service_docker_compose.service_name
       
       ScaffoldCliInvoker.cli_service_delete(runner, app_dir_path, service_name)
@@ -105,7 +105,7 @@ class TestScaffoldCli():
         assert False
 
     def test_service_delete_https(self, runner, app_dir_path, external_https_service_docker_compose):
-      app = App(app_dir_path, DOCKER_NAMESPACE)
+      app = App(app_dir_path, SERVICES_NAMESPACE)
       service_name = external_https_service_docker_compose.service_name
       hostname = external_https_service_docker_compose.hostname
 

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

@@ -7,7 +7,7 @@ import pytest
 
 from stoobly_agent.app.cli.scaffold.app import App
 from stoobly_agent.app.cli.scaffold.constants import (
-  DOCKER_NAMESPACE,
+  SERVICES_NAMESPACE,
   WORKFLOW_RECORD_TYPE,
   WORKFLOW_TEST_TYPE,
 )
@@ -138,7 +138,7 @@ class TestScaffoldE2e():
       shutil.rmtree(app_dir_path)
 
     def test_core_services(self, app_dir_path, target_workflow_name):
-      app = App(app_dir_path, DOCKER_NAMESPACE)
+      app = App(app_dir_path, SERVICES_NAMESPACE)
       config = {
         'workflow_name': target_workflow_name,
         'service_name': 'build'
@@ -148,7 +148,7 @@ class TestScaffoldE2e():
       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)
+      app = App(app_dir_path, SERVICES_NAMESPACE)
       config = {
         'workflow_name': target_workflow_name,
         'service_name': external_service_docker_compose.service_name 
@@ -158,7 +158,7 @@ class TestScaffoldE2e():
       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)
+      app = App(app_dir_path, SERVICES_NAMESPACE)
       config = {
         'workflow_name': target_workflow_name,
         'service_name': local_service_docker_compose.service_name 
@@ -223,7 +223,7 @@ class TestScaffoldE2e():
       ScaffoldCliInvoker.cli_service_create(runner, app_dir_path, external_service_docker_compose.hostname, external_service_docker_compose.service_name, False)
       # Create local user defined services
       ScaffoldCliInvoker.cli_service_create(runner, app_dir_path, local_service_docker_compose.hostname, local_service_docker_compose.service_name, False)
-      ScaffoldCliInvoker.cli_service_create_assets(runner, app_dir_path, assets_service_docker_compose.hostname, assets_service_docker_compose.service_name, False)
+      ScaffoldCliInvoker.cli_service_create_assets(runner, app_dir_path, assets_service_docker_compose.hostname, assets_service_docker_compose.service_name, True)
 
       # Don't run the local user defined service in the 'test' workflow
       # So don't copy the Docker Compose file over
@@ -233,17 +233,17 @@ class TestScaffoldE2e():
       assert destination_path.is_file()
       shutil.copyfile(assets_service_mock_docker_compose_path, destination_path)
 
-      ScaffoldCliInvoker.cli_service_create_assets(runner, app_dir_path, assets_service_docker_compose.hostname, assets_service_docker_compose.service_name, False)
+      ScaffoldCliInvoker.cli_service_create_assets(runner, app_dir_path, assets_service_docker_compose.hostname, assets_service_docker_compose.service_name, True)
 
       # 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_assets_path = f"{data_dir_path}/{SERVICES_NAMESPACE}/{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)
+      app = App(app_dir_path, SERVICES_NAMESPACE)
       config = {
         'workflow_name': target_workflow_name,
         'service_name': external_service_docker_compose.service_name 
@@ -261,7 +261,7 @@ class TestScaffoldE2e():
       shutil.rmtree(app_dir_path)
 
     def test_no_core_services(self, app_dir_path, target_workflow_name):
-      app = App(app_dir_path, DOCKER_NAMESPACE)
+      app = App(app_dir_path, SERVICES_NAMESPACE)
       config = {
         'workflow_name': target_workflow_name,
         'service_name': 'build'
@@ -271,7 +271,7 @@ class TestScaffoldE2e():
       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)
+      app = App(app_dir_path, SERVICES_NAMESPACE)
 
       config = {
         'workflow_name': target_workflow_name,
@@ -292,7 +292,7 @@ class TestScaffoldE2e():
       pass
 
     def test_assets(self, app_dir_path, target_workflow_name):
-      app = App(app_dir_path, DOCKER_NAMESPACE)
+      app = App(app_dir_path, SERVICES_NAMESPACE)
       config = {
         'workflow_name': target_workflow_name,
         'service_name': 'assets'

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

@@ -1 +1 @@
-1.9.6
+1.9.12