This is an automated email from the ASF dual-hosted git repository. shuber pushed a commit to branch unomi-3-dev in repository https://gitbox.apache.org/repos/asf/unomi.git
commit 1fd2d60e96144bf9048dd60915c3937695b4b44d Author: Serge Huber <[email protected]> AuthorDate: Wed Jan 21 15:08:39 2026 +0100 [UNOMI-879] test(shell): add comprehensive integration test suite for shell commands - Add ShellCommandsBaseIT base class with command execution utilities - Add CrudCommandsIT for testing unified CRUD operations - Add CacheCommandsIT for cache management command tests - Add TailCommandsIT for event and rule tail command tests - Add SchedulerCommandsIT for task scheduling command tests - Add TenantCommandsIT for tenant management command tests - Add RuleStatisticsCommandsIT for rule statistics command tests - Add OtherCommandsIT for miscellaneous shell command tests - Add test resources for CRUD operations (goals, rules, schemas, scopes, segments, topics) - Update BaseIT to include GoalsService for test support - Update AllITs to include all new shell command test classes --- .../test/java/org/apache/unomi/itests/AllITs.java | 10 +- .../test/java/org/apache/unomi/itests/BaseIT.java | 3 + .../apache/unomi/itests/shell/CacheCommandsIT.java | 137 ++++ .../apache/unomi/itests/shell/CrudCommandsIT.java | 728 +++++++++++++++++++++ .../apache/unomi/itests/shell/OtherCommandsIT.java | 67 ++ .../itests/shell/RuleStatisticsCommandsIT.java | 133 ++++ .../unomi/itests/shell/SchedulerCommandsIT.java | 150 +++++ .../unomi/itests/shell/ShellCommandsBaseIT.java | 466 +++++++++++++ .../apache/unomi/itests/shell/TailCommandsIT.java | 45 ++ .../unomi/itests/shell/TenantCommandsIT.java | 93 +++ .../src/test/resources/shell/crud/test-goal.json | 9 + .../src/test/resources/shell/crud/test-rule.json | 14 + .../src/test/resources/shell/crud/test-schema.json | 19 + .../src/test/resources/shell/crud/test-scope.json | 5 + .../test/resources/shell/crud/test-segment.json | 12 + .../src/test/resources/shell/crud/test-topic.json | 9 + 16 files changed, 1899 insertions(+), 1 deletion(-) diff --git a/itests/src/test/java/org/apache/unomi/itests/AllITs.java b/itests/src/test/java/org/apache/unomi/itests/AllITs.java index 659a13e03..f664f9ae0 100644 --- a/itests/src/test/java/org/apache/unomi/itests/AllITs.java +++ b/itests/src/test/java/org/apache/unomi/itests/AllITs.java @@ -20,6 +20,7 @@ package org.apache.unomi.itests; import org.apache.unomi.itests.migration.Migrate16xToCurrentVersionIT; import org.apache.unomi.itests.graphql.*; import org.apache.unomi.itests.migration.MigrationIT; +import org.apache.unomi.itests.shell.*; import org.junit.runner.RunWith; import org.junit.runners.Suite.SuiteClasses; @@ -68,7 +69,14 @@ import org.junit.runners.Suite.SuiteClasses; ScopeIT.class, HealthCheckIT.class, LegacyQueryBuilderMappingIT.class, - V2CompatibilityModeIT.class + V2CompatibilityModeIT.class, + CrudCommandsIT.class, + CacheCommandsIT.class, + TailCommandsIT.class, + SchedulerCommandsIT.class, + TenantCommandsIT.class, + RuleStatisticsCommandsIT.class, + OtherCommandsIT.class }) public class AllITs { } diff --git a/itests/src/test/java/org/apache/unomi/itests/BaseIT.java b/itests/src/test/java/org/apache/unomi/itests/BaseIT.java index 03f91e4f6..cc44265bd 100644 --- a/itests/src/test/java/org/apache/unomi/itests/BaseIT.java +++ b/itests/src/test/java/org/apache/unomi/itests/BaseIT.java @@ -162,6 +162,7 @@ public abstract class BaseIT extends KarafTestSupport { protected EventService eventService; protected BundleWatcher bundleWatcher; protected GroovyActionsService groovyActionsService; + protected GoalsService goalsService; protected SegmentService segmentService; protected SchemaService schemaService; protected ScopeService scopeService; @@ -257,6 +258,7 @@ public abstract class BaseIT extends KarafTestSupport { privacyService = getOsgiService(PrivacyService.class, 600000); eventService = getOsgiService(EventService.class, 600000); groovyActionsService = getOsgiService(GroovyActionsService.class, 600000); + goalsService = getOsgiService(GoalsService.class, 600000); segmentService = getOsgiService(SegmentService.class, 600000); schemaService = getOsgiService(SchemaService.class, 600000); scopeService = getOsgiService(ScopeService.class, 600000); @@ -931,6 +933,7 @@ public abstract class BaseIT extends KarafTestSupport { eventService = getService(EventService.class); bundleWatcher = getService(BundleWatcher.class); groovyActionsService = getService(GroovyActionsService.class); + goalsService = getService(GoalsService.class); schemaService = getService(SchemaService.class); scopeService = getService(ScopeService.class); patchService = getService(PatchService.class); diff --git a/itests/src/test/java/org/apache/unomi/itests/shell/CacheCommandsIT.java b/itests/src/test/java/org/apache/unomi/itests/shell/CacheCommandsIT.java new file mode 100644 index 000000000..13e920c34 --- /dev/null +++ b/itests/src/test/java/org/apache/unomi/itests/shell/CacheCommandsIT.java @@ -0,0 +1,137 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.unomi.itests.shell; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Integration tests for unomi:cache command. + */ +public class CacheCommandsIT extends ShellCommandsBaseIT { + + @Test + public void testCacheStats() throws Exception { + String output = executeCommandAndGetOutput("unomi:cache --stats"); + assertContainsAny(output, new String[]{"Statistics for type:", "Hits:", "Misses:"}, + "Should show statistics for type"); + + // If statistics are shown, validate they contain numeric values + if (output.contains("Hits:")) { + validateNumericValuesInOutput(output, new String[]{"Hits:", "Misses:", "Updates:"}, false); + } + } + + @Test + public void testCacheStatsWithReset() throws Exception { + String output = executeCommandAndGetOutput("unomi:cache --stats --reset"); + // Should show statistics and reset confirmation + assertContainsAny(output, new String[]{"Statistics have been reset", "Statistics for type:"}, + "Should show statistics have been reset"); + + // If no explicit reset message, at least verify stats were shown + if (!output.contains("Statistics have been reset")) { + assertContainsAny(output, new String[]{"Statistics for type:", "Hits:"}, + "Should show cache statistics"); + } + } + + @Test + public void testCacheStatsWithTenant() throws Exception { + String output = executeCommandAndGetOutput("unomi:cache --stats --tenant " + TEST_TENANT_ID); + // Should show statistics (may be empty if no cache activity) + // Note: --tenant option sets the tenantId but displayStatistics() doesn't filter by tenant, + // so it shows all statistics. The output may be empty if there are no statistics at all. + // Empty output is valid (means no statistics available) + if (output.trim().isEmpty()) { + // Empty output is acceptable - means no statistics available + return; + } + + assertContainsAny(output, new String[]{ + "Statistics for type:", + "Hits:", + "No statistics available", + "Cache service not available" + }, "Should show cache statistics, indicate no stats, or service unavailable"); + + // If stats are shown, they should be valid + if (output.contains("Statistics for type:")) { + assertContainsAny(output, new String[]{"Hits:", "Misses:"}, + "Should contain Hits or Misses when stats are shown"); + } + } + + @Test + public void testCacheClear() throws Exception { + String output = executeCommandAndGetOutput("unomi:cache --clear --tenant " + TEST_TENANT_ID); + // Should confirm cache was cleared with the specific tenant ID + Assert.assertTrue("Should confirm cache cleared for tenant", + output.contains("Cache cleared for tenant: " + TEST_TENANT_ID)); + } + + @Test + public void testCacheInspect() throws Exception { + String output = executeCommandAndGetOutput("unomi:cache --inspect"); + // Inspect should show cache contents or ask for type + assertContainsAny(output, new String[]{ + "Cache contents for tenant:", + "Please specify a type to inspect", + "Timestamp:" + }, "Should show cache contents or request type"); + + // If it shows contents, should have tenant info + if (output.contains("Cache contents for tenant:")) { + Assert.assertTrue("Should show timestamp when contents are displayed", + output.contains("Timestamp:")); + } + } + + @Test + public void testCacheStatsWithType() throws Exception { + String output = executeCommandAndGetOutput("unomi:cache --stats --type profile"); + // Should show stats for the specific type or indicate no stats + assertContainsAny(output, new String[]{ + "Statistics for type: profile", + "No statistics available for type: profile", + "Hits:" + }, "Should show statistics for profile type or indicate no stats"); + + // If stats are shown, verify they're for the correct type + if (output.contains("Statistics for type: profile")) { + assertContainsAny(output, new String[]{"Hits:", "Misses:"}, + "Should show Hits or Misses for profile type"); + } + } + + @Test + public void testCacheDetailedStats() throws Exception { + String output = executeCommandAndGetOutput("unomi:cache --stats --detailed"); + // Detailed stats should show additional metrics like efficiency score + assertContainsAny(output, new String[]{ + "Statistics for type:", + "Efficiency Score:", + "Error Rate:", + "Hits:" + }, "Should show detailed statistics"); + + // If detailed stats are shown, verify they contain numeric values (allow decimals) + if (output.contains("Efficiency Score:") || output.contains("Error Rate:")) { + validateNumericValuesInOutput(output, new String[]{"Efficiency Score:", "Error Rate:"}, true); + } + } +} diff --git a/itests/src/test/java/org/apache/unomi/itests/shell/CrudCommandsIT.java b/itests/src/test/java/org/apache/unomi/itests/shell/CrudCommandsIT.java new file mode 100644 index 000000000..48a8632be --- /dev/null +++ b/itests/src/test/java/org/apache/unomi/itests/shell/CrudCommandsIT.java @@ -0,0 +1,728 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.unomi.itests.shell; + +import org.apache.unomi.api.goals.Goal; +import org.apache.unomi.api.rules.Rule; +import org.apache.unomi.api.segments.Segment; +import org.apache.unomi.api.Topic; +import org.apache.unomi.api.Scope; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Integration tests for unomi:crud command. + * Tests CRUD operations for various object types including schema. + */ +public class CrudCommandsIT extends ShellCommandsBaseIT { + + private List<String> createdItemIds = new ArrayList<>(); + private List<File> tempFiles = new ArrayList<>(); + + @Before + public void setUp() { + createdItemIds.clear(); + tempFiles.clear(); + } + + @After + public void tearDown() { + // Clean up created items - try CRUD delete first, then fall back to services + for (String itemId : new ArrayList<>(createdItemIds)) { + cleanupItem(itemId); + } + createdItemIds.clear(); + + // Clean up temp files + for (File file : tempFiles) { + try { + if (file.exists()) { + file.delete(); + } + } catch (Exception e) { + // Don't log here - any logging can be captured by command output stream causing StackOverflow + } + } + tempFiles.clear(); + } + + /** + * Clean up a single item by trying various deletion methods. + */ + private void cleanupItem(String itemId) { + // Try CRUD delete for common types + if (tryCrudDelete(itemId)) { + return; + } + + // Fall back to direct service calls if CRUD didn't work + tryServiceDeletion(itemId); + } + + /** + * Try to delete an item using CRUD commands. + * + * @param itemId the item ID to delete + * @return true if deletion was successful + */ + private boolean tryCrudDelete(String itemId) { + String[] types = {"goal", "rule", "segment", "topic", "scope", "schema"}; + for (String type : types) { + try { + String output = executeCommandAndGetOutput("unomi:crud delete " + type + " " + itemId); + if (output.contains("Deleted")) { + return true; + } + } catch (Exception e) { + // Try next type + } + } + return false; + } + + /** + * Try to delete an item using direct service calls. + * + * @param itemId the item ID to delete + */ + private void tryServiceDeletion(String itemId) { + try { + if (rulesService != null) { + Rule rule = rulesService.getRule(itemId); + if (rule != null) { + rulesService.removeRule(itemId); + return; + } + } + if (goalsService != null) { + Goal goal = goalsService.getGoal(itemId); + if (goal != null) { + goalsService.removeGoal(itemId); + return; + } + } + if (segmentService != null) { + Segment segment = segmentService.getSegmentDefinition(itemId); + if (segment != null) { + segmentService.removeSegmentDefinition(itemId, false); + return; + } + } + if (topicService != null) { + Topic topic = topicService.load(itemId); + if (topic != null) { + topicService.delete(itemId); + return; + } + } + if (scopeService != null) { + Scope scope = scopeService.getScope(itemId); + if (scope != null) { + scopeService.delete(itemId); + return; + } + } + if (schemaService != null) { + try { + schemaService.deleteSchema(itemId); + } catch (Exception e) { + // Ignore schema deletion errors + } + } + } catch (Exception e) { + // Don't log here - any logging can be captured by command output stream causing StackOverflow + } + } + + /** + * Create a temporary JSON file with the given content. + */ + private File createTempJsonFile(String content) throws IOException { + Path tempFile = Files.createTempFile("unomi-test-", ".json"); + File file = tempFile.toFile(); + file.deleteOnExit(); + try (FileWriter writer = new FileWriter(file)) { + writer.write(content); + } + tempFiles.add(file); + return file; + } + + // ========== Goal Tests ========== + + @Test + public void testGoalCrudOperations() throws Exception { + String goalId = createTestId("test-goal"); + + // Test create + createGoal(goalId, "Test Goal", "Test goal description"); + createdItemIds.add(goalId); + + // Test read and validate + validateGoalRead(goalId, "Test Goal", "Test goal description"); + + // Test update + updateGoal(goalId, "Updated Goal", "Updated description"); + validateGoalRead(goalId, "Updated Goal", "Updated description"); + + // Test list + validateGoalInList(goalId); + validateListWithLimit("goal", 5); + + // Test delete + deleteGoal(goalId); + validateGoalNotFound(goalId); + } + + /** + * Create a goal via CRUD command. + */ + private void createGoal(String goalId, String name, String description) throws Exception { + String createJson = String.format( + "{\"itemId\":\"%s\",\"metadata\":{\"id\":\"%s\",\"name\":\"%s\",\"description\":\"%s\",\"scope\":\"systemscope\",\"enabled\":true}}", + goalId, goalId, name, description + ); + // Quote JSON to ensure it's treated as a single argument (prevents Gogo shell from interpreting {} as closure) + String createOutput = executeCommandAndGetOutput( + String.format("unomi:crud create goal '%s'", createJson) + ); + Assert.assertTrue("Goal should be created", + createOutput.contains("Created goal with ID: " + goalId) || createOutput.contains(goalId)); + } + + /** + * Validate goal read operation and field values. + */ + private void validateGoalRead(String goalId, String expectedName, String expectedDescription) throws Exception { + String readOutput = executeCommandAndGetOutput("unomi:crud read goal " + goalId); + Assert.assertTrue("Should read goal", readOutput.contains(goalId)); + Assert.assertTrue("Should contain goal name", readOutput.contains(expectedName)); + + Map<String, Object> goalData = parseJsonOutput(readOutput); + Assert.assertNotNull("Goal data should be parsed", goalData); + + Map<String, Object> expectedFields = new HashMap<>(); + expectedFields.put("itemId", goalId); + expectedFields.put("metadata.name", expectedName); + expectedFields.put("metadata.description", expectedDescription); + validateJsonFields(goalData, expectedFields); + } + + /** + * Update a goal via CRUD command. + */ + private void updateGoal(String goalId, String name, String description) throws Exception { + String updateJson = String.format( + "{\"itemId\":\"%s\",\"metadata\":{\"id\":\"%s\",\"name\":\"%s\",\"description\":\"%s\",\"scope\":\"systemscope\",\"enabled\":true}}", + goalId, goalId, name, description + ); + // Quote JSON to ensure it's treated as a single argument (prevents Gogo shell from interpreting {} as closure) + String updateOutput = executeCommandAndGetOutput( + String.format("unomi:crud update goal %s '%s'", goalId, updateJson) + ); + Assert.assertTrue("Goal should be updated", updateOutput.contains("Updated goal with ID: " + goalId)); + } + + /** + * Validate goal appears in list. + * Uses retry logic to handle eventual consistency. + */ + private void validateGoalInList(String goalId) throws Exception { + // Wait for goal to appear in list with retries + boolean found = waitForCondition( + "Goal should appear in list", + () -> { + try { + String listOutput = executeCommandAndGetOutput("unomi:crud list goal"); + validateTableHeaders(listOutput, new String[]{"ID", "Tenant", "Identifier"}); + return tableContainsValue(listOutput, goalId); + } catch (Exception e) { + return false; + } + }, + 5, // maxRetries + 200 // retryDelayMs + ); + Assert.assertTrue("Goal should be found in table", found); + } + + /** + * Validate list command with limit. + */ + private void validateListWithLimit(String objectType, int limit) throws Exception { + String listOutput = executeCommandAndGetOutput( + String.format("unomi:crud list %s -n %d", objectType, limit) + ); + validateTableHeaders(listOutput, new String[]{"ID", "Tenant"}); + } + + /** + * Delete a goal via CRUD command. + */ + private void deleteGoal(String goalId) throws Exception { + String deleteOutput = executeCommandAndGetOutput("unomi:crud delete goal " + goalId); + Assert.assertTrue("Goal should be deleted", deleteOutput.contains("Deleted goal with ID: " + goalId)); + createdItemIds.remove(goalId); + } + + /** + * Validate that a goal is not found. + */ + private void validateGoalNotFound(String goalId) throws Exception { + String readOutput = executeCommandAndGetOutput("unomi:crud read goal " + goalId); + assertContainsAny(readOutput, new String[]{"not found", "null"}, + "Should indicate goal not found"); + } + + @Test + public void testGoalCreateWithFile() throws Exception { + String goalId = createTestId("test-goal-file"); + String goalJson = String.format( + "{\"itemId\":\"%s\",\"metadata\":{\"id\":\"%s\",\"name\":\"File Goal\",\"description\":\"Goal from file\",\"scope\":\"systemscope\",\"enabled\":true}}", + goalId, goalId + ); + File jsonFile = createTempJsonFile(goalJson); + + // Quote file path to handle spaces or special characters + String filePath = jsonFile.getAbsolutePath().replace("'", "'\"'\"'"); + String output = executeCommandAndGetOutput("unomi:crud create goal file://" + filePath); + Assert.assertTrue("Goal should be created from file", + output.contains("Created goal with ID: " + goalId) || output.contains(goalId)); + createdItemIds.add(goalId); + } + + @Test + public void testGoalHelp() throws Exception { + String helpOutput = executeCommandAndGetOutput("unomi:crud help goal"); + Assert.assertTrue("Should show help", helpOutput.contains("Required properties") || helpOutput.contains("itemId")); + } + + @Test + public void testGoalListCsv() throws Exception { + String csvOutput = executeCommandAndGetOutput("unomi:crud list goal --csv"); + // CSV should contain commas and have at least one line + Assert.assertTrue("Should output CSV format", csvOutput.contains(",") || csvOutput.trim().length() > 0); + // CSV should have multiple lines (header + data rows, even if empty) + String[] lines = csvOutput.split("\n"); + Assert.assertTrue("CSV output should have at least one line", lines.length > 0); + } + + @Test + public void testGoalListWithCsvAndLimit() throws Exception { + // Test combining --csv and -n options + String csvOutput = executeCommandAndGetOutput("unomi:crud list goal --csv -n 10"); + // CSV should contain commas and have at least one line + Assert.assertTrue("Should output CSV format", csvOutput.contains(",") || csvOutput.trim().length() > 0); + // CSV should have multiple lines (header + data rows, even if empty) + String[] lines = csvOutput.split("\n"); + Assert.assertTrue("CSV output should have at least one line", lines.length > 0); + } + + /** + * Helper method to test basic CRUD operations for an object type. + * Reduces code duplication across similar object types. + * + * @param objectType the object type (e.g., "rule", "segment") + * @param jsonTemplate JSON template with two %s placeholders for itemId (used twice in metadata.id and itemId) + */ + private void testBasicCrudOperations(String objectType, String jsonTemplate) throws Exception { + String itemId = createTestId("test-" + objectType); + String json = String.format(jsonTemplate, itemId, itemId); + + // Test create with retry logic for condition type resolution timing issues + boolean created = waitForCondition( + objectType + " should be created", + () -> { + try { + String createOutput = executeCommandAndGetOutput( + String.format("unomi:crud create %s '%s'", objectType, json) + ); + // Check for success indicators + boolean success = createOutput.contains("Created " + objectType + " with ID: " + itemId) || + createOutput.contains(itemId); + // Check for condition resolution errors that might resolve with retry + boolean isRetryableError = createOutput.contains("Condition type is missing") || + createOutput.contains("could not be resolved") || + createOutput.contains("Invalid rule condition") || + createOutput.contains("Invalid segment condition"); + if (success) { + createdItemIds.add(itemId); + return true; + } else if (isRetryableError) { + return false; // Retry for condition resolution errors + } + return false; // Other errors, will fail assertion + } catch (Exception e) { + // Check if it's a condition resolution error that might resolve with retry + String errorMsg = e.getMessage(); + if (errorMsg != null && (errorMsg.contains("Condition type is missing") || + errorMsg.contains("could not be resolved") || + errorMsg.contains("Invalid rule condition") || + errorMsg.contains("Invalid segment condition"))) { + return false; // Retry + } + // For other exceptions, return false and let assertion fail with original error + return false; + } + }, + 5, // maxRetries - condition types should be available, but allow more retries + 300 // retryDelayMs - give time for DefinitionsService to be ready + ); + Assert.assertTrue(objectType + " should be created", created); + + // Test read - parse JSON and validate + String readOutput = executeCommandAndGetOutput("unomi:crud read " + objectType + " " + itemId); + Assert.assertTrue("Should read " + objectType, readOutput.contains(itemId)); + + // Parse JSON to ensure valid structure + try { + Map<String, Object> readData = parseJsonOutput(readOutput); + Assert.assertNotNull(objectType + " data should be parsed", readData); + Assert.assertEquals(objectType + " itemId should match", itemId, readData.get("itemId")); + } catch (Exception e) { + // If JSON parsing fails, at least verify the ID is in the output + Assert.assertTrue("Should contain " + objectType + " ID in output", readOutput.contains(itemId)); + } + + // Test list - validate table structure with retry logic for eventual consistency + // Different object types have different headers, so we check for common ones + boolean foundInList = waitForCondition( + objectType + " should appear in list", + () -> { + try { + String listOutput = executeCommandAndGetOutput("unomi:crud list " + objectType); + // Check for common headers that appear in most list outputs + // "Tenant" is always present, and "Identifier" or "ID" appears for most types + validateTableHeaders(listOutput, new String[]{"Tenant", "Identifier", "ID"}); + return tableContainsValue(listOutput, itemId); + } catch (Exception e) { + return false; + } + }, + 5, // maxRetries + 200 // retryDelayMs + ); + Assert.assertTrue("Should contain our " + objectType + " ID in the list", foundInList); + + // Test delete + String deleteOutput = executeCommandAndGetOutput("unomi:crud delete " + objectType + " " + itemId); + Assert.assertTrue(objectType + " should be deleted", + deleteOutput.contains("Deleted " + objectType + " with ID: " + itemId)); + createdItemIds.remove(itemId); + } + + // ========== Rule Tests ========== + + @Test + public void testRuleCrudOperations() throws Exception { + // Include parameterValues (even if empty) to ensure proper condition deserialization + String ruleJsonTemplate = + "{\"itemId\":\"%s\",\"metadata\":{\"id\":\"%s\",\"name\":\"Test Rule\",\"description\":\"Test rule\",\"scope\":\"systemscope\",\"enabled\":true},\"condition\":{\"type\":\"matchAllCondition\",\"parameterValues\":{}},\"actions\":[]}"; + testBasicCrudOperations("rule", ruleJsonTemplate); + } + + // ========== Segment Tests ========== + + @Test + public void testSegmentCrudOperations() throws Exception { + // Include parameterValues (even if empty) to ensure proper condition deserialization + String segmentJsonTemplate = + "{\"itemId\":\"%s\",\"metadata\":{\"id\":\"%s\",\"name\":\"Test Segment\",\"description\":\"Test segment\",\"scope\":\"systemscope\"},\"condition\":{\"type\":\"matchAllCondition\",\"parameterValues\":{}}}"; + testBasicCrudOperations("segment", segmentJsonTemplate); + } + + // ========== Topic Tests ========== + + @Test + public void testTopicCrudOperations() throws Exception { + // Topic extends Item (not MetadataItem), so it doesn't have metadata property + // Topic has: itemId, topicId, name, scope (from Item) + String topicJsonTemplate = + "{\"itemId\":\"%s\",\"topicId\":\"%s\",\"name\":\"Test Topic\",\"scope\":\"systemscope\"}"; + testBasicCrudOperations("topic", topicJsonTemplate); + } + + // ========== Scope Tests ========== + + @Test + public void testScopeCrudOperations() throws Exception { + String scopeJsonTemplate = + "{\"itemId\":\"%s\",\"metadata\":{\"id\":\"%s\",\"name\":\"Test Scope\",\"description\":\"Test scope\",\"scope\":\"systemscope\"}}"; + testBasicCrudOperations("scope", scopeJsonTemplate); + } + + // ========== Schema Tests ========== + + @Test + public void testSchemaCrudOperations() throws Exception { + String schemaId = "https://unomi.apache.org/schemas/json/test/"; + createTestId("test-schema"); + + // Create a simple schema + // Note: self.name must match [_A-Za-z][_0-9A-Za-z]* (no spaces, must start with letter/underscore) + String schemaJson = String.format( + "{\"$id\":\"%s\",\"self\":{\"target\":\"events\",\"name\":\"TestSchema\"},\"type\":\"object\",\"properties\":{\"testProperty\":{\"type\":\"string\"}}}", + schemaId + ); + // Quote JSON to ensure it's treated as a single argument + String createOutput = executeCommandAndGetOutput( + String.format("unomi:crud create schema '%s'", schemaJson) + ); + Assert.assertTrue("Schema should be created", + createOutput.contains("Created schema with ID: " + schemaId) || createOutput.contains(schemaId)); + createdItemIds.add(schemaId); + + // Test read - parse JSON and validate schema structure + String readOutput = executeCommandAndGetOutput("unomi:crud read schema " + schemaId); + Assert.assertTrue("Should read schema", readOutput.contains(schemaId)); + + Map<String, Object> schemaData = parseJsonOutput(readOutput); + Assert.assertNotNull("Schema data should be parsed", schemaData); + + // Schema read returns a wrapped structure: {id, name, target, tenantId, schema: {...}} + // The actual schema is nested under "schema" key + Map<String, Object> expectedSchemaFields = new HashMap<>(); + expectedSchemaFields.put("id", schemaId); + // Check that schema.type exists in the nested schema object + Assert.assertTrue("Schema data should contain 'schema' key", schemaData.containsKey("schema")); + @SuppressWarnings("unchecked") + Map<String, Object> actualSchema = (Map<String, Object>) schemaData.get("schema"); + Assert.assertNotNull("Nested schema should not be null", actualSchema); + Assert.assertEquals("Schema type should be 'object'", "object", actualSchema.get("type")); + + // Test list + String listOutput = executeCommandAndGetOutput("unomi:crud list schema"); + validateTableHeaders(listOutput, new String[]{"ID", "Tenant"}); + + // Test delete + String deleteOutput = executeCommandAndGetOutput("unomi:crud delete schema " + schemaId); + Assert.assertTrue("Schema should be deleted", deleteOutput.contains("Deleted schema with ID: " + schemaId)); + createdItemIds.remove(schemaId); + } + + // ========== Error Handling Tests ========== + + @Test + public void testReadNonExistentGoal() throws Exception { + String nonExistentId = "non-existent-goal-" + System.currentTimeMillis(); + String output = executeCommandAndGetOutput("unomi:crud read goal " + nonExistentId); + assertContainsAny(output, new String[]{"not found", "null"}, + "Should indicate goal not found"); + } + + @Test + public void testCreateWithInvalidJson() throws Exception { + // Quote even invalid JSON to ensure it's treated as a single argument + String output = executeCommandAndGetOutput("unomi:crud create goal '[[invalid json]]'"); + assertContainsAny(output, new String[]{"error", "Error", "Exception"}, + "Should show error for invalid JSON"); + } + + @Test + public void testDeleteWithoutId() throws Exception { + String output = executeCommandAndGetOutput("unomi:crud delete goal"); + assertContainsAny(output, new String[]{"required", "ID"}, + "Should require ID"); + } + + @Test + public void testUpdateWithoutId() throws Exception { + String output = executeCommandAndGetOutput("unomi:crud update goal"); + assertContainsAny(output, new String[]{"required", "ID", "Error"}, + "Should require ID and JSON"); + } + + // ========== Syntax Error Tests ========== + + @Test + public void testCreateWithUnquotedJson() throws Exception { + // Unquoted JSON may be interpreted as closure or cause parsing errors + String unquotedJson = "{\"itemId\":\"test\",\"metadata\":{\"id\":\"test\",\"name\":\"Test\",\"scope\":\"systemscope\"}}"; + String output = executeCommandAndGetOutput( + String.format("unomi:crud create goal %s", unquotedJson) + ); + // Should either fail with parsing error or be interpreted incorrectly + assertContainsAny(output, new String[]{"error", "Error", "Exception", "Too many arguments", "parse", "syntax"}, + "Should show error for unquoted JSON"); + } + + @Test + public void testCreateWithMalformedJson() throws Exception { + // Missing closing brace + String output = executeCommandAndGetOutput("unomi:crud create goal '{\"itemId\":\"test\"'"); + assertContainsAny(output, new String[]{"error", "Error", "Exception", "parse", "invalid"}, + "Should show error for malformed JSON"); + } + + @Test + public void testCreateWithEmptyJson() throws Exception { + String output = executeCommandAndGetOutput("unomi:crud create goal '{}'"); + // Empty JSON might be valid but should show validation error for missing required fields + assertContainsAny(output, new String[]{"error", "Error", "required", "itemId", "Exception"}, + "Should show error for empty or incomplete JSON"); + } + + @Test + public void testUpdateWithMissingJson() throws Exception { + String goalId = createTestId("test-goal-syntax"); + // Update with ID but no JSON + String output = executeCommandAndGetOutput("unomi:crud update goal " + goalId); + assertContainsAny(output, new String[]{"required", "JSON", "Error"}, + "Should require JSON for update operation"); + } + + @Test + public void testUpdateWithOnlyJsonNoId() throws Exception { + // Update with JSON but no ID (missing ID argument) + String json = "'{\"itemId\":\"test\",\"metadata\":{\"id\":\"test\",\"name\":\"Test\",\"scope\":\"systemscope\"}}'"; + String output = executeCommandAndGetOutput("unomi:crud update goal " + json); + // Should fail because ID is required as first remaining argument + // The JSON will be treated as remaining[0], but we need remaining[0] = ID, remaining[1] = JSON + assertContainsAny(output, new String[]{"required", "ID", "Error", "JSON"}, + "Should require ID as first argument for update"); + } + + @Test + public void testReadWithExtraArguments() throws Exception { + // Read should only take ID, extra arguments will be in remaining list but ignored + String nonExistentId = "non-existent-" + System.currentTimeMillis(); + String output = executeCommandAndGetOutput("unomi:crud read goal " + nonExistentId + " extra-arg"); + // With multi-valued remaining, extra args are captured but ignored for read operation + // Should show "not found" error, not "too many arguments" + assertContainsAny(output, new String[]{"not found", "null", "error", "Error"}, + "Should handle extra arguments gracefully (ignore them, show not found)"); + } + + @Test + public void testDeleteWithExtraArguments() throws Exception { + // Delete should only take ID, extra arguments will be in remaining list but ignored + String nonExistentId = "non-existent-" + System.currentTimeMillis(); + String output = executeCommandAndGetOutput("unomi:crud delete goal " + nonExistentId + " extra-arg"); + // With multi-valued remaining, extra args are captured but ignored for delete operation + // Should show "not found" or similar, not "too many arguments" + assertContainsAny(output, new String[]{"not found", "error", "Error", "Deleted"}, + "Should handle extra arguments gracefully (ignore them)"); + } + + @Test + public void testListWithInvalidOptionValue() throws Exception { + // -n option should have a numeric value + String output = executeCommandAndGetOutput("unomi:crud list goal -n invalid"); + // Should either ignore invalid value or show error + assertContainsAny(output, new String[]{"ID", "error", "Error", "invalid", "number"}, + "Should handle invalid option value (may ignore or show error)"); + } + + @Test + public void testListWithNegativeLimit() throws Exception { + // Negative limit might be invalid + String output = executeCommandAndGetOutput("unomi:crud list goal -n -5"); + // Should either ignore negative value or show error + assertContainsAny(output, new String[]{"ID", "error", "Error", "invalid"}, + "Should handle negative limit (may ignore or show error)"); + } + + @Test + public void testCreateWithInvalidUrl() throws Exception { + // Invalid file URL (file doesn't exist) + String output = executeCommandAndGetOutput("unomi:crud create goal file:///nonexistent/path/file.json"); + assertContainsAny(output, new String[]{"error", "Error", "Exception", "not found", "No such file"}, + "Should show error for invalid file URL"); + } + + @Test + public void testCreateWithInvalidUrlFormat() throws Exception { + // Unsupported URL scheme (valid URI format but scheme not supported) + // With improved URL detection, this will be detected as a URL and show unsupported scheme error + String output = executeCommandAndGetOutput("unomi:crud create goal invalid://url"); + assertContainsAny(output, new String[]{"error", "Error", "Exception", "unsupported", "scheme", "not yet supported", "Failed to parse"}, + "Should show error for unsupported URL scheme"); + } + + @Test + public void testCreateWithJsonContainingUnescapedQuotes() throws Exception { + // JSON with unescaped quotes inside (should be properly escaped in the test) + // This tests that the quoting mechanism works correctly + // Note: description should be in metadata for Goal + String jsonWithQuotes = "{\"itemId\":\"test\",\"metadata\":{\"id\":\"test\",\"name\":\"Test\",\"description\":\"Test with 'single' quotes\",\"scope\":\"systemscope\"}}"; + String output = executeCommandAndGetOutput( + String.format("unomi:crud create goal '%s'", jsonWithQuotes) + ); + // Should either succeed (if quotes are handled) or show error + assertContainsAny(output, new String[]{"Created", "error", "Error", "parse"}, + "Should handle JSON with quotes (may succeed or show parse error)"); + } + + @Test + public void testCreateWithMissingType() throws Exception { + // Missing type argument - Karaf will throw CommandException before our code runs + try { + String output = executeCommandAndGetOutput("unomi:crud create"); + // If we get here, check for error message + assertContainsAny(output, new String[]{"required", "type", "Error", "usage", "Usage", "Argument type is required"}, + "Should require type argument"); + } catch (Exception e) { + // CommandException is expected for missing required arguments + Assert.assertTrue("Should throw exception for missing type", + e.getMessage().contains("required") || e.getMessage().contains("type") || + e.getClass().getSimpleName().contains("CommandException")); + } + } + + @Test + public void testCreateWithMissingOperation() throws Exception { + // Missing operation (just type) - Karaf will throw CommandException before our code runs + try { + String output = executeCommandAndGetOutput("unomi:crud goal"); + // If we get here, check for error message + assertContainsAny(output, new String[]{"required", "operation", "Error", "usage", "Usage", "Unknown", "Argument type is required"}, + "Should require operation argument"); + } catch (Exception e) { + // CommandException is expected for missing required arguments + Assert.assertTrue("Should throw exception for missing operation", + e.getMessage().contains("required") || e.getMessage().contains("type") || + e.getClass().getSimpleName().contains("CommandException")); + } + } + + @Test + public void testInvalidOperation() throws Exception { + // Invalid operation name + String output = executeCommandAndGetOutput("unomi:crud invalid-operation goal"); + assertContainsAny(output, new String[]{"Unknown", "invalid", "Error", "operation", "usage", "Usage"}, + "Should show error for invalid operation"); + } + + @Test + public void testInvalidType() throws Exception { + // Invalid type (not supported) + String output = executeCommandAndGetOutput("unomi:crud create invalid-type '{\"itemId\":\"test\"}'"); + assertContainsAny(output, new String[]{"Unknown", "invalid", "Error", "type", "not found", "not supported"}, + "Should show error for invalid type"); + } +} diff --git a/itests/src/test/java/org/apache/unomi/itests/shell/OtherCommandsIT.java b/itests/src/test/java/org/apache/unomi/itests/shell/OtherCommandsIT.java new file mode 100644 index 000000000..76d7303d4 --- /dev/null +++ b/itests/src/test/java/org/apache/unomi/itests/shell/OtherCommandsIT.java @@ -0,0 +1,67 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.unomi.itests.shell; + +import org.junit.Assert; +import org.junit.Test; + +import java.util.List; + +/** + * Integration tests for other utility commands. + */ +public class OtherCommandsIT extends ShellCommandsBaseIT { + + @Test + public void testRuleResetStats() throws Exception { + String output = executeCommandAndGetOutput("unomi:rule-reset-stats"); + // Should confirm statistics were reset + Assert.assertTrue("Should confirm rule statistics reset", + output.contains("Rule statistics successfully reset")); + } + + @Test + public void testListInvalidObjects() throws Exception { + String output = executeCommandAndGetOutput("unomi:list-invalid-objects"); + // Should show summary or indicate no invalid objects + assertContainsAny(output, new String[]{ + "Invalid Objects Summary", + "Total invalid objects:", + "No invalid objects found" + }, "Should show invalid objects summary or indicate none found"); + + // If summary is shown, verify it contains a numeric count + if (output.contains("Total invalid objects:")) { + validateNumericValuesInOutput(output, new String[]{"Total invalid objects:"}, false); + } + + // If table is shown, verify structure + if (output.contains("Object Type") && output.contains("Object ID")) { + validateTableHeaders(output, new String[]{"Object Type", "Object ID"}); + } + } + + @Test + public void testDeployDefinition() throws Exception { + validateCommandExists("unomi:deploy-definition", "deploy", "definition"); + } + + @Test + public void testUndeployDefinition() throws Exception { + validateCommandExists("unomi:undeploy-definition", "undeploy", "definition"); + } +} diff --git a/itests/src/test/java/org/apache/unomi/itests/shell/RuleStatisticsCommandsIT.java b/itests/src/test/java/org/apache/unomi/itests/shell/RuleStatisticsCommandsIT.java new file mode 100644 index 000000000..4c4ef1b5e --- /dev/null +++ b/itests/src/test/java/org/apache/unomi/itests/shell/RuleStatisticsCommandsIT.java @@ -0,0 +1,133 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.unomi.itests.shell; + +import org.apache.unomi.api.rules.Rule; +import org.apache.unomi.api.services.RulesService; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; + +/** + * Integration tests for rule statistics commands. + */ +public class RuleStatisticsCommandsIT extends ShellCommandsBaseIT { + + private List<String> createdRuleIds = new ArrayList<>(); + + @Before + public void setUp() { + createdRuleIds.clear(); + } + + @After + public void tearDown() { + for (String ruleId : createdRuleIds) { + try { + if (rulesService != null) { + Rule rule = rulesService.getRule(ruleId); + if (rule != null) { + rulesService.removeRule(ruleId); + } + } + } catch (Exception e) { + // Don't log here - any logging can be captured by command output stream causing StackOverflow + } + } + createdRuleIds.clear(); + } + + @Test + public void testRuleStatisticsList() throws Exception { + // Rule statistics are accessed via unomi:crud list rulestats + String output = executeCommandAndGetOutput("unomi:crud list rulestats"); + // Should show statistics table with headers + assertContainsAny(output, new String[]{ + "ID", "Executions", "Conditions Time", "Tenant" + }, "Should show rule statistics table headers"); + + // If table is shown, verify structure + if (output.contains("ID") && output.contains("Executions")) { + List<List<String>> rows = extractTableRows(output); + // Should have table structure + Assert.assertTrue("Should have table structure", rows.size() >= 0); + } + } + + @Test + public void testRuleStatisticsReset() throws Exception { + // Rule statistics reset is done via unomi:crud delete rulestats -i <id> or unomi:rule-reset-stats + // The delete operation on rulestats resets all statistics + String output = executeCommandAndGetOutput("unomi:rule-reset-stats"); + // Should confirm statistics were reset + Assert.assertTrue("Should confirm rule statistics reset", + output.contains("Rule statistics successfully reset")); + } + + @Test + public void testRuleStatisticsAfterRuleExecution() throws Exception { + String ruleId = createTestRuleForStatistics(); + String statsOutput = executeCommandAndGetOutput("unomi:crud list rulestats"); + validateRuleStatisticsTable(statsOutput, ruleId); + verifyRuleStatisticsReset(); + } + + /** + * Create a test rule and return its ID. + */ + private String createTestRuleForStatistics() throws Exception { + String ruleId = createTestId("test-rule-stats"); + String createOutput = createTestRule(ruleId, "Test Rule Stats"); + Assert.assertTrue("Rule should be created", + createOutput.contains("Created rule with ID: " + ruleId) || createOutput.contains(ruleId)); + createdRuleIds.add(ruleId); + return ruleId; + } + + /** + * Verify that rule statistics can be reset. + */ + private void verifyRuleStatisticsReset() throws Exception { + String resetOutput = executeCommandAndGetOutput("unomi:rule-reset-stats"); + Assert.assertTrue("Should confirm statistics reset", + resetOutput.contains("Rule statistics successfully reset")); + } + + /** + * Validate that rule statistics table is properly formatted. + */ + private void validateRuleStatisticsTable(String statsOutput, String ruleId) { + assertContainsAny(statsOutput, new String[]{ + "ID", "Executions", "Tenant", "Conditions Time" + }, "Should show statistics table with headers"); + + // Verify our rule appears in the statistics (may have 0 executions) + Assert.assertTrue("Should contain our rule ID in statistics", + statsOutput.contains(ruleId) || statsOutput.contains("ID")); + + // If table is shown, verify structure + if (statsOutput.contains("ID") && statsOutput.contains("Executions")) { + validateTableHeaders(statsOutput, new String[]{"ID", "Executions"}); + List<List<String>> rows = extractTableRows(statsOutput); + Assert.assertTrue("Statistics table should be present", rows.size() >= 0); + } + } +} diff --git a/itests/src/test/java/org/apache/unomi/itests/shell/SchedulerCommandsIT.java b/itests/src/test/java/org/apache/unomi/itests/shell/SchedulerCommandsIT.java new file mode 100644 index 000000000..7cc98380f --- /dev/null +++ b/itests/src/test/java/org/apache/unomi/itests/shell/SchedulerCommandsIT.java @@ -0,0 +1,150 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.unomi.itests.shell; + +import org.junit.Assert; +import org.junit.Test; + +import java.util.regex.Pattern; + +/** + * Integration tests for scheduler commands. + */ +public class SchedulerCommandsIT extends ShellCommandsBaseIT { + + private static final Pattern TASK_COUNT_PATTERN = + Pattern.compile("Showing\\s+(\\d+)\\s+task"); + + @Test + public void testTaskList() throws Exception { + String output = executeCommandAndGetOutput("unomi:task-list"); + // Should show task list table with headers or "No tasks found" + assertContainsAny(output, new String[]{"ID", "No tasks found", "Showing"}, + "Should show task list table with headers or indicate no tasks"); + + // If tasks are shown, verify table structure + if (hasTableHeaders(output, "ID", "Type", "Status")) { + validateTableHeaders(output, new String[]{"ID", "Type", "Status"}); + validateTaskCountIfPresent(output); + } + } + + /** + * Check if output contains all specified headers. + */ + private boolean hasTableHeaders(String output, String... headers) { + for (String header : headers) { + if (!output.contains(header)) { + return false; + } + } + return true; + } + + /** + * Validate task count if present in output. + */ + private void validateTaskCountIfPresent(String output) { + if (output.contains("Showing") && output.contains("task")) { + int count = extractNumericValue(output, TASK_COUNT_PATTERN); + Assert.assertTrue("Task count should be extracted and valid", count >= 0); + } + } + + @Test + public void testTaskShowWithInvalidId() throws Exception { + String nonExistentId = "non-existent-task-" + System.currentTimeMillis(); + String output = executeCommandAndGetOutput("unomi:task-show " + nonExistentId); + // Should indicate task not found with the specific ID + validateErrorMessage(output, "Task not found:", nonExistentId); + } + + @Test + public void testTaskPurge() throws Exception { + // Note: task-purge requires confirmation, so we use --force flag + String output = executeCommandAndGetOutput("unomi:task-purge --force"); + assertContainsAny(output, new String[]{"Successfully purged", "purged"}, + "Should confirm purge completed"); + + // If purge was successful, verify it contains a count or confirmation message + if (output.contains("Successfully purged")) { + // Check if there's a number after "purged" (with optional "tasks" or similar) + boolean hasCount = output.matches(".*Successfully purged\\s+\\d+.*") || + output.matches(".*purged\\s+\\d+.*"); + // If no explicit count, at least verify the message is present + Assert.assertTrue("Purge confirmation should contain task count or confirmation", + hasCount || output.contains("purged")); + } + } + + @Test + public void testTaskShowOutputFormat() throws Exception { + String nonExistentId = "test-task-" + System.currentTimeMillis(); + String output = executeCommandAndGetOutput("unomi:task-show " + nonExistentId); + validateErrorMessage(output, "Task not found:", nonExistentId); + } + + @Test + public void testTaskListWithStatusFilter() throws Exception { + testTaskListWithFilter("-s COMPLETED", "COMPLETED", "with status"); + } + + @Test + public void testTaskListWithTypeFilter() throws Exception { + testTaskListWithFilter("-t testType", "testType", "of type"); + } + + /** + * Helper method to test task list filtering. + * + * @param filterOption the filter option (e.g., "-s=COMPLETED", "-t=testType") + * @param filterValue the filter value to check in output + * @param filterLabel the label that should appear in output (e.g., "with status", "of type") + */ + private void testTaskListWithFilter(String filterOption, String filterValue, String filterLabel) throws Exception { + String output = executeCommandAndGetOutput("unomi:task-list " + filterOption); + assertContainsAny(output, new String[]{"ID", "No tasks found"}, + "Should show task list or indicate no tasks"); + + // If tasks are shown, verify filter was applied + if (output.contains("Showing") && output.contains("task") && output.contains(filterValue)) { + assertContainsAny(output, new String[]{filterLabel, filterValue}, + "Should show filter in output"); + } + } + + @Test + public void testTaskListWithLimit() throws Exception { + String output = executeCommandAndGetOutput("unomi:task-list --limit 10"); + validateTableHeaders(output, new String[]{"ID", "Type", "Status"}); + + // Verify limit was applied (should show max 10 tasks) + validateTaskCountLimit(output, 10); + } + + /** + * Validate that task count respects the specified limit. + */ + private void validateTaskCountLimit(String output, int maxLimit) { + if (output.contains("Showing") && output.contains("task")) { + int count = extractNumericValue(output, TASK_COUNT_PATTERN); + if (count >= 0) { + Assert.assertTrue("Task count should respect limit of " + maxLimit, count <= maxLimit); + } + } + } +} diff --git a/itests/src/test/java/org/apache/unomi/itests/shell/ShellCommandsBaseIT.java b/itests/src/test/java/org/apache/unomi/itests/shell/ShellCommandsBaseIT.java new file mode 100644 index 000000000..cea6e52dc --- /dev/null +++ b/itests/src/test/java/org/apache/unomi/itests/shell/ShellCommandsBaseIT.java @@ -0,0 +1,466 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.unomi.itests.shell; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.apache.unomi.itests.BaseIT; +import org.apache.unomi.persistence.spi.CustomObjectMapper; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.junit.Assert; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.function.Supplier; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Base class for shell command integration tests. + * Provides common utilities for command execution and output parsing. + */ +public abstract class ShellCommandsBaseIT extends BaseIT { + + protected static final Logger LOGGER = LoggerFactory.getLogger(ShellCommandsBaseIT.class); + + /** + * Get ObjectMapper for JSON parsing. + * Uses CustomObjectMapper for consistency with Unomi's JSON handling. + * This ensures proper deserialization of Unomi Item types and maintains + * the same date formatting and configuration as the rest of the system. + * + * Note: This is lazy-initialized to avoid class loading issues before OSGi is ready. + */ + protected ObjectMapper getJsonMapper() { + return CustomObjectMapper.getObjectMapper(); + } + + /** + * Execute a shell command and capture its output as a string. + * Temporarily disables InMemoryLogAppender during execution to prevent StackOverflow + * caused by recursive output capture in Karaf shell streams. + * + * @param command the command to execute + * @return the command output + */ + protected String executeCommandAndGetOutput(String command) { + String output = executeCommand(command); + // Return empty string if output is null to avoid NPE + return output != null ? output : ""; + } + + /** + * Execute a command and verify the output contains expected text. + * + * @param command the command to execute + * @param expectedOutput the expected text in the output + */ + protected void executeCommandAndVerify(String command, String expectedOutput) { + String output = executeCommandAndGetOutput(command); + if (!output.contains(expectedOutput)) { + throw new AssertionError("Expected output to contain '" + expectedOutput + + "' but got: " + output); + } + } + + /** + * Parse JSON output from a command. + * Attempts to extract JSON from the output string. + * + * @param output the command output + * @return parsed JSON as a Map + */ + @SuppressWarnings("unchecked") + protected Map<String, Object> parseJsonOutput(String output) { + try { + // Try to find JSON in the output (may be mixed with other text) + int jsonStart = output.indexOf('{'); + int jsonEnd = output.lastIndexOf('}'); + if (jsonStart >= 0 && jsonEnd > jsonStart) { + String jsonStr = output.substring(jsonStart, jsonEnd + 1); + return (Map<String, Object>) getJsonMapper().readValue(jsonStr, Map.class); + } + // If no JSON found, try parsing the whole output + return (Map<String, Object>) getJsonMapper().readValue(output, Map.class); + } catch (Exception e) { + // Don't log here - any logging can be captured by command output stream causing StackOverflow + // Just throw exception without logging + throw new RuntimeException("Failed to parse JSON output", e); + } + } + + /** + * Verify table output contains expected headers. + * + * @param output the command output + * @param expectedHeaders the expected column headers + */ + protected void verifyTableOutput(String output, String[] expectedHeaders) { + for (String header : expectedHeaders) { + if (!output.contains(header)) { + throw new AssertionError("Expected table to contain header '" + header + + "' but got: " + output); + } + } + } + + /** + * Extract table rows from command output. + * Assumes output is in Karaf ShellTable format. + * + * @param output the command output + * @return list of rows, each row is a list of cell values + */ + protected List<List<String>> extractTableRows(String output) { + List<List<String>> rows = new ArrayList<>(); + String[] lines = output.split("\n"); + + boolean inTable = false; + for (String line : lines) { + line = line.trim(); + if (line.isEmpty()) { + continue; + } + + // Check if this is a table separator line + if (line.matches("^[+-]+$")) { + inTable = true; + continue; + } + + if (inTable && !line.isEmpty()) { + // Split by multiple spaces (table columns) + String[] cells = line.split("\\s{2,}"); + if (cells.length > 0) { + List<String> row = new ArrayList<>(); + for (String cell : cells) { + row.add(cell.trim()); + } + rows.add(row); + } + } + } + + return rows; + } + + /** + * Extract CSV rows from command output. + * + * @param output the command output + * @return list of rows, each row is a list of cell values + */ + protected List<List<String>> extractCsvRows(String output) { + List<List<String>> rows = new ArrayList<>(); + String[] lines = output.split("\n"); + + for (String line : lines) { + line = line.trim(); + if (line.isEmpty()) { + continue; + } + + String[] cells = line.split(","); + List<String> row = new ArrayList<>(); + for (String cell : cells) { + row.add(cell.trim()); + } + rows.add(row); + } + + return rows; + } + + /** + * Create a unique test ID with timestamp. + * + * @param prefix the prefix for the ID + * @return a unique ID + */ + protected String createTestId(String prefix) { + return prefix + "-" + System.currentTimeMillis() + "-" + Thread.currentThread().getId(); + } + + /** + * Wait for a condition to be true, with retries. + * + * @param message the message to log + * @param condition the condition supplier + * @param maxRetries maximum number of retries + * @param retryDelayMs delay between retries in milliseconds + * @return true if condition became true, false otherwise + */ + protected boolean waitForCondition(String message, Supplier<Boolean> condition, + int maxRetries, long retryDelayMs) { + for (int i = 0; i < maxRetries; i++) { + if (condition.get()) { + return true; + } + if (i < maxRetries - 1) { + try { + Thread.sleep(retryDelayMs); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + return false; + } + } + } + // Don't log here - any logging can be captured by command output stream causing StackOverflow + return false; + } + + /** + * Validate that a line contains a numeric value after a label. + * + * @param line the line to validate + * @param label the label to look for (e.g., "Hits:", "Total:") + * @param allowDecimal whether to allow decimal numbers (true) or only integers (false) + * @return true if the line contains the label followed by a valid number + */ + protected boolean validateNumericValue(String line, String label, boolean allowDecimal) { + if (!line.contains(label)) { + return false; + } + String[] parts = line.split(":"); + if (parts.length > 1) { + String value = parts[1].trim(); + // Remove percentage sign if present + value = value.replace("%", "").trim(); + String pattern = allowDecimal ? "\\d+(\\.\\d+)?" : "\\d+"; + return value.matches(pattern); + } + return false; + } + + /** + * Validate numeric values in output lines for given labels. + * + * @param output the command output + * @param labels the labels to validate (e.g., "Hits:", "Misses:") + * @param allowDecimal whether to allow decimal numbers + */ + protected void validateNumericValuesInOutput(String output, String[] labels, boolean allowDecimal) { + String[] lines = output.split("\n"); + for (String line : lines) { + for (String label : labels) { + if (line.contains(label)) { + Assert.assertTrue("Value after " + label + " should be numeric: " + line, + validateNumericValue(line, label, allowDecimal)); + } + } + } + } + + /** + * Extract a numeric value from a line that matches a pattern. + * + * @param output the command output + * @param pattern the regex pattern with a capturing group for the number + * @return the extracted number, or -1 if not found + */ + protected int extractNumericValue(String output, Pattern pattern) { + String[] lines = output.split("\n"); + for (String line : lines) { + Matcher matcher = pattern.matcher(line); + if (matcher.find()) { + try { + return Integer.parseInt(matcher.group(1)); + } catch (NumberFormatException e) { + // Continue to next line + } + } + } + return -1; + } + + /** + * Validate that output contains expected table headers. + * + * @param output the command output + * @param requiredHeaders at least one of these headers must be present + * @param optionalHeaders additional headers that may be present + */ + protected void validateTableHeaders(String output, String[] requiredHeaders, String... optionalHeaders) { + boolean foundRequired = false; + for (String header : requiredHeaders) { + if (output.contains(header)) { + foundRequired = true; + break; + } + } + Assert.assertTrue("Should contain at least one required table header: " + + Arrays.toString(requiredHeaders), foundRequired); + } + + /** + * Validate that a table contains a specific value in its rows. + * + * @param output the command output + * @param expectedValue the value to search for + * @return true if the value is found in the table + */ + protected boolean tableContainsValue(String output, String expectedValue) { + List<List<String>> rows = extractTableRows(output); + for (List<String> row : rows) { + if (row.contains(expectedValue)) { + return true; + } + } + // Also check raw output as fallback + return output.contains(expectedValue); + } + + /** + * Validate error message contains expected content. + * + * @param output the command output + * @param expectedErrorPattern the expected error pattern (e.g., "not found", "Error:") + * @param expectedId the ID that should appear in the error (if any) + */ + protected void validateErrorMessage(String output, String expectedErrorPattern, String expectedId) { + Assert.assertTrue("Should contain error pattern: " + expectedErrorPattern, + output.contains(expectedErrorPattern)); + if (expectedId != null) { + Assert.assertTrue("Error message should contain ID: " + expectedId, + output.contains(expectedId)); + } + } + + /** + * Test that a command exists by checking help or error handling. + * + * @param command the command to test + * @param expectedKeywords keywords that should appear in help output (if available) + */ + protected void validateCommandExists(String command, String... expectedKeywords) { + try { + String output = executeCommandAndGetOutput(command + " --help"); + if (output != null && output.length() > 0 && expectedKeywords.length > 0) { + boolean foundKeyword = false; + for (String keyword : expectedKeywords) { + if (output.contains(keyword)) { + foundKeyword = true; + break; + } + } + Assert.assertTrue("Help should contain command information", + foundKeyword || output.length() > 0); + } + } catch (Exception e) { + // Command might not have help or might require parameters + // Verify it's not a "command not found" error + String errorMsg = e.getMessage(); + if (errorMsg != null) { + Assert.assertFalse("Command should exist (error: " + errorMsg + ")", + errorMsg.contains("command not found") || + errorMsg.contains("CommandNotFoundException") || + errorMsg.contains("Unknown command")); + } + } + } + + /** + * Extract a value from output after a label. + * + * @param output the command output + * @param label the label to search for (e.g., "Current tenant ID:") + * @return the value after the label, or null if not found + */ + protected String extractValueAfterLabel(String output, String label) { + if (!output.contains(label)) { + return null; + } + String[] parts = output.split(Pattern.quote(label)); + if (parts.length > 1) { + return parts[1].trim().split("\\s")[0]; // Get first word after label + } + return null; + } + + /** + * Validate that output contains at least one of the given strings. + * + * @param output the command output + * @param possibleValues possible values that should appear in output + * @param message the assertion message + */ + protected void assertContainsAny(String output, String[] possibleValues, String message) { + boolean found = false; + for (String value : possibleValues) { + if (output.contains(value)) { + found = true; + break; + } + } + Assert.assertTrue(message, found); + } + + /** + * Validate JSON object structure and values. + * + * @param jsonData the parsed JSON data + * @param expectedFields map of field paths to expected values (e.g., "itemId" -> "test-123", "metadata.name" -> "Test") + */ + @SuppressWarnings("unchecked") + protected void validateJsonFields(Map<String, Object> jsonData, Map<String, Object> expectedFields) { + for (Map.Entry<String, Object> entry : expectedFields.entrySet()) { + String fieldPath = entry.getKey(); + Object expectedValue = entry.getValue(); + + String[] pathParts = fieldPath.split("\\."); + Object current = jsonData; + + for (String part : pathParts) { + if (current instanceof Map) { + current = ((Map<String, Object>) current).get(part); + if (current == null) { + Assert.fail("Field path '" + fieldPath + "' not found in JSON"); + return; + } + } else { + Assert.fail("Cannot navigate path '" + fieldPath + "' - intermediate value is not a map"); + return; + } + } + + Assert.assertEquals("Field '" + fieldPath + "' should match", expectedValue, current); + } + } + + /** + * Create a rule via CRUD command for testing. + * + * @param ruleId the rule ID + * @param ruleName the rule name + * @return the create command output + */ + protected String createTestRule(String ruleId, String ruleName) { + // Include parameterValues (even if empty) to ensure proper condition deserialization + String ruleJson = String.format( + "{\"itemId\":\"%s\",\"metadata\":{\"id\":\"%s\",\"name\":\"%s\",\"description\":\"Test\",\"scope\":\"systemscope\",\"enabled\":true},\"condition\":{\"type\":\"matchAllCondition\",\"parameterValues\":{}},\"actions\":[]}", + ruleId, ruleId, ruleName + ); + // Use new argument-based syntax: unomi:crud create rule '<json>' + // Quote JSON to ensure it's treated as a single argument (prevents Gogo shell from interpreting {} as closure) + return executeCommandAndGetOutput( + String.format("unomi:crud create rule '%s'", ruleJson) + ); + } +} diff --git a/itests/src/test/java/org/apache/unomi/itests/shell/TailCommandsIT.java b/itests/src/test/java/org/apache/unomi/itests/shell/TailCommandsIT.java new file mode 100644 index 000000000..903cb67a6 --- /dev/null +++ b/itests/src/test/java/org/apache/unomi/itests/shell/TailCommandsIT.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.unomi.itests.shell; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Integration tests for event-tail and rule-tail commands. + * Note: These are streaming commands that may need special handling. + */ +public class TailCommandsIT extends ShellCommandsBaseIT { + + @Test + public void testEventTailCommandExists() throws Exception { + // Note: event-tail is a streaming command that may not have help + validateCommandExists("unomi:event-tail", "event", "tail"); + } + + @Test + public void testRuleTailCommandExists() throws Exception { + // Note: rule-tail is a streaming command + validateCommandExists("unomi:rule-tail", "rule", "tail"); + } + + @Test + public void testRuleWatchCommandExists() throws Exception { + // Note: rule-watch is a streaming command + validateCommandExists("unomi:rule-watch", "rule", "watch"); + } +} diff --git a/itests/src/test/java/org/apache/unomi/itests/shell/TenantCommandsIT.java b/itests/src/test/java/org/apache/unomi/itests/shell/TenantCommandsIT.java new file mode 100644 index 000000000..cdeafb392 --- /dev/null +++ b/itests/src/test/java/org/apache/unomi/itests/shell/TenantCommandsIT.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.unomi.itests.shell; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Integration tests for tenant context commands. + */ +public class TenantCommandsIT extends ShellCommandsBaseIT { + + @Test + public void testGetCurrentTenant() throws Exception { + String output = executeCommandAndGetOutput("unomi:tenant-get"); + // Should show current tenant ID or indicate no tenant set + assertContainsAny(output, new String[]{"Current tenant ID:", "No current tenant set"}, + "Should show current tenant or indicate none set"); + + // If tenant is set, verify the format + if (output.contains("Current tenant ID:")) { + String tenantId = extractValueAfterLabel(output, "Current tenant ID:"); + Assert.assertNotNull("Should contain tenant ID value", tenantId); + } + } + + @Test + public void testSetCurrentTenant() throws Exception { + // Set to test tenant + String output = executeCommandAndGetOutput("unomi:tenant-set " + TEST_TENANT_ID); + Assert.assertTrue("Should confirm tenant was set", + output.contains("Current tenant set to: " + TEST_TENANT_ID)); + + // Verify tenant details are shown + assertContainsAny(output, new String[]{"Tenant details:", "Name:", "Status:"}, + "Should show tenant details"); + + // Note: Tenant context is stored in Karaf shell session, which may not persist + // between separate executeCommand calls in tests. The set command itself + // confirms the tenant was set, which is what we're testing here. + } + + @Test + public void testSetCurrentTenantWithInvalidId() throws Exception { + String invalidTenantId = "invalid-tenant-" + System.currentTimeMillis(); + String output = executeCommandAndGetOutput("unomi:tenant-set " + invalidTenantId); + // Should indicate tenant not found with the specific ID + validateErrorMessage(output, "not found", invalidTenantId); + + // Verify tenant was NOT set by checking current tenant + String getOutput = executeCommandAndGetOutput("unomi:tenant-get"); + Assert.assertFalse("Should not have set invalid tenant", + getOutput.contains("Current tenant ID: " + invalidTenantId)); + } + + /** + * Verify that the current tenant matches the expected value. + */ + private void verifyCurrentTenant(String expectedTenantId) throws Exception { + String output = executeCommandAndGetOutput("unomi:tenant-get"); + Assert.assertTrue("Should show the set tenant ID", + output.contains("Current tenant ID: " + expectedTenantId)); + String actualTenantId = extractValueAfterLabel(output, "Current tenant ID:"); + Assert.assertEquals("Tenant ID should match", expectedTenantId, actualTenantId); + } + + @Test + public void testTenantContextSwitching() throws Exception { + // Set to test tenant + String setOutput = executeCommandAndGetOutput("unomi:tenant-set " + TEST_TENANT_ID); + Assert.assertTrue("Should confirm tenant was set", + setOutput.contains("Current tenant set to: " + TEST_TENANT_ID)); + + // Note: Tenant context is stored in Karaf shell session, which may not persist + // between separate executeCommand calls in tests. The set command itself + // confirms the tenant was set, which is what we're testing here. + // In a real interactive shell session, the tenant would persist between commands. + } +} diff --git a/itests/src/test/resources/shell/crud/test-goal.json b/itests/src/test/resources/shell/crud/test-goal.json new file mode 100644 index 000000000..9cd17893c --- /dev/null +++ b/itests/src/test/resources/shell/crud/test-goal.json @@ -0,0 +1,9 @@ +{ + "itemId": "test-goal-from-file", + "metadata": { + "name": "Test Goal from File", + "description": "A test goal created from JSON file", + "scope": "systemscope" + }, + "enabled": true +} diff --git a/itests/src/test/resources/shell/crud/test-rule.json b/itests/src/test/resources/shell/crud/test-rule.json new file mode 100644 index 000000000..b05eacd49 --- /dev/null +++ b/itests/src/test/resources/shell/crud/test-rule.json @@ -0,0 +1,14 @@ +{ + "itemId": "test-rule-from-file", + "metadata": { + "id": "test-rule-from-file", + "name": "Test Rule from File", + "description": "A test rule created from JSON file", + "scope": "systemscope", + "enabled": true + }, + "condition": { + "type": "matchAllCondition" + }, + "actions": [] +} diff --git a/itests/src/test/resources/shell/crud/test-schema.json b/itests/src/test/resources/shell/crud/test-schema.json new file mode 100644 index 000000000..86fa33ad9 --- /dev/null +++ b/itests/src/test/resources/shell/crud/test-schema.json @@ -0,0 +1,19 @@ +{ + "$id": "https://unomi.apache.org/schemas/json/test/test-schema-from-file";, + "self": { + "target": "events", + "name": "Test Schema from File" + }, + "type": "object", + "properties": { + "testProperty": { + "type": "string", + "description": "A test property" + }, + "testNumber": { + "type": "number", + "description": "A test number property" + } + }, + "required": ["testProperty"] +} diff --git a/itests/src/test/resources/shell/crud/test-scope.json b/itests/src/test/resources/shell/crud/test-scope.json new file mode 100644 index 000000000..887e234f0 --- /dev/null +++ b/itests/src/test/resources/shell/crud/test-scope.json @@ -0,0 +1,5 @@ +{ + "itemId": "test-scope-from-file", + "name": "Test Scope from File", + "description": "A test scope created from JSON file" +} diff --git a/itests/src/test/resources/shell/crud/test-segment.json b/itests/src/test/resources/shell/crud/test-segment.json new file mode 100644 index 000000000..d24cef9d8 --- /dev/null +++ b/itests/src/test/resources/shell/crud/test-segment.json @@ -0,0 +1,12 @@ +{ + "itemId": "test-segment-from-file", + "metadata": { + "id": "test-segment-from-file", + "name": "Test Segment from File", + "description": "A test segment created from JSON file", + "scope": "systemscope" + }, + "condition": { + "type": "matchAllCondition" + } +} diff --git a/itests/src/test/resources/shell/crud/test-topic.json b/itests/src/test/resources/shell/crud/test-topic.json new file mode 100644 index 000000000..e539ac122 --- /dev/null +++ b/itests/src/test/resources/shell/crud/test-topic.json @@ -0,0 +1,9 @@ +{ + "itemId": "test-topic-from-file", + "metadata": { + "id": "test-topic-from-file", + "name": "Test Topic from File", + "description": "A test topic created from JSON file", + "scope": "systemscope" + } +}
