decision_agent 0.1.7 → 0.3.0

data/spec/web_ui_rack_spec.rb

@@ -1439,6 +1439,300 @@ RSpec.describe "DecisionAgent Web UI Rack Integration" do
     end
   end
 
+  describe "Versioning API integration tests with real FileStorageAdapter" do
+    let(:temp_storage_path) { Dir.mktmpdir("versioning_test_") }
+    let(:authenticator) { DecisionAgent::Web::Server.authenticator }
+    let(:user) do
+      u = authenticator.create_user(
+        email: "versioninteg@example.com",
+        password: "password123",
+        roles: [:editor]
+      )
+      session = authenticator.login("versioninteg@example.com", "password123")
+      { user: u, session: session }
+    end
+
+    before do
+      # Create a real FileStorageAdapter and inject it into the server's version_manager
+      real_adapter = DecisionAgent::Versioning::FileStorageAdapter.new(storage_path: temp_storage_path)
+      real_version_manager = DecisionAgent::Versioning::VersionManager.new(adapter: real_adapter)
+
+      # Stub the version_manager method to return our real manager
+      allow_any_instance_of(DecisionAgent::Web::Server).to receive(:version_manager).and_return(real_version_manager)
+    end
+
+    after do
+      # Clean up temp directory
+      FileUtils.rm_rf(temp_storage_path)
+    end
+
+    describe "POST /api/versions" do
+      it "creates a version with real file storage" do
+        rule_content = {
+          version: "1.0",
+          ruleset: "test_rules",
+          rules: [{
+            id: "rule1",
+            if: { field: "amount", op: "gt", value: 100 },
+            then: { decision: "approve", weight: 0.9, reason: "High amount" }
+          }]
+        }
+
+        post "/api/versions",
+             {
+               rule_id: "integration_test_rule",
+               content: rule_content,
+               created_by: "integration@example.com",
+               changelog: "Integration test version"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        expect(last_response.status).to eq(201)
+        json = JSON.parse(last_response.body)
+        expect(json["rule_id"]).to eq("integration_test_rule")
+        expect(json["version_number"]).to eq(1)
+        expect(json["status"]).to eq("active") # FileStorageAdapter defaults to "active"
+        expect(json["created_by"]).to eq("integration@example.com")
+
+        # Verify file was actually created
+        rule_dir = File.join(temp_storage_path, "integration_test_rule")
+        expect(Dir.exist?(rule_dir)).to be true
+        version_file = File.join(rule_dir, "1.json")
+        expect(File.exist?(version_file)).to be true
+
+        # Verify content
+        stored_content = JSON.parse(File.read(version_file))
+        # JSON parsing returns string keys, so we compare by converting both to same format
+        expected_content = JSON.parse(JSON.generate(rule_content))
+        expect(stored_content["content"]).to eq(expected_content)
+      end
+
+      it "creates multiple versions and increments version number" do
+        rule_content = { version: "1.0", ruleset: "test", rules: [] }
+
+        # Create first version
+        post "/api/versions",
+             {
+               rule_id: "multi_version_rule",
+               content: rule_content,
+               created_by: "test@example.com"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        expect(last_response.status).to eq(201)
+        json1 = JSON.parse(last_response.body)
+        expect(json1["version_number"]).to eq(1)
+
+        # Create second version
+        post "/api/versions",
+             {
+               rule_id: "multi_version_rule",
+               content: rule_content.merge(version: "2.0"),
+               created_by: "test@example.com"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        expect(last_response.status).to eq(201)
+        json2 = JSON.parse(last_response.body)
+        expect(json2["version_number"]).to eq(2)
+      end
+    end
+
+    describe "GET /api/rules/:rule_id/versions" do
+      it "returns versions from real file storage" do
+        rule_content = { version: "1.0", ruleset: "test", rules: [] }
+
+        # Create two versions
+        post "/api/versions",
+             {
+               rule_id: "list_test_rule",
+               content: rule_content,
+               created_by: "test@example.com"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        post "/api/versions",
+             {
+               rule_id: "list_test_rule",
+               content: rule_content,
+               created_by: "test@example.com"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        # List versions
+        get "/api/rules/list_test_rule/versions", {}, { "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        expect(last_response.status).to eq(200)
+        json = JSON.parse(last_response.body)
+        expect(json).to be_an(Array)
+        expect(json.length).to eq(2)
+        expect(json.first["version_number"]).to eq(2) # Most recent first
+        expect(json.last["version_number"]).to eq(1)
+      end
+
+      it "respects limit parameter" do
+        rule_content = { version: "1.0", ruleset: "test", rules: [] }
+
+        # Create three versions
+        3.times do
+          post "/api/versions",
+               {
+                 rule_id: "limit_test_rule",
+                 content: rule_content,
+                 created_by: "test@example.com"
+               }.to_json,
+               { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+        end
+
+        # List with limit
+        get "/api/rules/limit_test_rule/versions?limit=2", {}, { "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        expect(last_response.status).to eq(200)
+        json = JSON.parse(last_response.body)
+        expect(json.length).to eq(2)
+      end
+    end
+
+    describe "GET /api/rules/:rule_id/history" do
+      it "returns history from real file storage" do
+        rule_content = { version: "1.0", ruleset: "test", rules: [] }
+
+        # Create a version
+        post "/api/versions",
+             {
+               rule_id: "history_test_rule",
+               content: rule_content,
+               created_by: "test@example.com",
+               changelog: "Test changelog"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        # Get history
+        get "/api/rules/history_test_rule/history", {}, { "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        expect(last_response.status).to eq(200)
+        json = JSON.parse(last_response.body)
+        expect(json).to be_a(Hash)
+        expect(json["total_versions"]).to eq(1)
+        expect(json["versions"]).to be_an(Array)
+        expect(json["versions"].length).to eq(1)
+      end
+    end
+
+    describe "GET /api/versions/:version_id" do
+      it "retrieves a specific version from real file storage" do
+        rule_content = {
+          version: "1.0",
+          ruleset: "test",
+          rules: [{ id: "test_rule", if: { field: "x", op: "eq", value: 1 }, then: { decision: "yes" } }]
+        }
+
+        # Create a version
+        post "/api/versions",
+             {
+               rule_id: "get_version_test",
+               content: rule_content,
+               created_by: "test@example.com"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        version_json = JSON.parse(last_response.body)
+        version_id = version_json["id"]
+
+        # Get the version
+        get "/api/versions/#{version_id}", {}, { "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        expect(last_response.status).to eq(200)
+        json = JSON.parse(last_response.body)
+        expect(json["id"]).to eq(version_id)
+        expect(json["rule_id"]).to eq("get_version_test")
+        # JSON parsing returns string keys, so we compare by converting both to same format
+        expected_content = JSON.parse(JSON.generate(rule_content))
+        expect(json["content"]).to eq(expected_content)
+      end
+    end
+
+    describe "POST /api/versions/:version_id/activate" do
+      it "activates a version with real file storage" do
+        # Create admin user for deploy permission
+        authenticator.create_user(
+          email: "deployadmin@example.com",
+          password: "password123",
+          roles: [:admin]
+        )
+        admin_session = authenticator.login("deployadmin@example.com", "password123")
+
+        rule_content = { version: "1.0", ruleset: "test", rules: [] }
+
+        # Create a version
+        post "/api/versions",
+             {
+               rule_id: "activate_test_rule",
+               content: rule_content,
+               created_by: "test@example.com"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        version_json = JSON.parse(last_response.body)
+        version_id = version_json["id"]
+
+        # Activate the version
+        post "/api/versions/#{version_id}/activate",
+             { performed_by: "admin@example.com" }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{admin_session.token}" }
+
+        expect(last_response.status).to eq(200)
+        json = JSON.parse(last_response.body)
+        expect(json["id"]).to eq(version_id)
+        expect(json["status"]).to eq("active")
+
+        # Verify it's active by getting the version again
+        get "/api/versions/#{version_id}", {}, { "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+        active_json = JSON.parse(last_response.body)
+        expect(active_json["status"]).to eq("active")
+      end
+    end
+
+    describe "GET /api/versions/:version_id_1/compare/:version_id_2" do
+      it "compares two versions from real file storage" do
+        base_content = { version: "1.0", ruleset: "test", rules: [{ id: "r1" }] }
+        modified_content = { version: "1.0", ruleset: "test", rules: [{ id: "r1" }, { id: "r2" }] }
+
+        # Create first version
+        post "/api/versions",
+             {
+               rule_id: "compare_test_rule",
+               content: base_content,
+               created_by: "test@example.com"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+        v1_json = JSON.parse(last_response.body)
+        v1_id = v1_json["id"]
+
+        # Create second version
+        post "/api/versions",
+             {
+               rule_id: "compare_test_rule",
+               content: modified_content,
+               created_by: "test@example.com"
+             }.to_json,
+             { "CONTENT_TYPE" => "application/json", "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+        v2_json = JSON.parse(last_response.body)
+        v2_id = v2_json["id"]
+
+        # Compare versions
+        get "/api/versions/#{v1_id}/compare/#{v2_id}", {}, { "HTTP_AUTHORIZATION" => "Bearer #{user[:session].token}" }
+
+        expect(last_response.status).to eq(200)
+        json = JSON.parse(last_response.body)
+        expect(json).to be_a(Hash)
+        expect(json).to have_key("version_1") # compare_versions returns version_1 and version_2
+        expect(json).to have_key("version_2")
+        expect(json).to have_key("differences")
+      end
+    end
+  end
+
   describe "Batch Testing API comprehensive tests" do
     describe "POST /api/testing/batch/import" do
       it "handles Excel file import" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: decision_agent
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.3.0
 platform: ruby
 authors:
 - Sam Aswin
@@ -37,6 +37,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: roo
   requirement: !ruby/object:Gem::Requirement
@@ -174,6 +202,25 @@ files:
 - lib/decision_agent/auth/user.rb
 - lib/decision_agent/context.rb
 - lib/decision_agent/decision.rb
+- lib/decision_agent/dmn/adapter.rb
+- lib/decision_agent/dmn/cache.rb
+- lib/decision_agent/dmn/decision_graph.rb
+- lib/decision_agent/dmn/decision_tree.rb
+- lib/decision_agent/dmn/errors.rb
+- lib/decision_agent/dmn/exporter.rb
+- lib/decision_agent/dmn/feel/evaluator.rb
+- lib/decision_agent/dmn/feel/functions.rb
+- lib/decision_agent/dmn/feel/parser.rb
+- lib/decision_agent/dmn/feel/simple_parser.rb
+- lib/decision_agent/dmn/feel/transformer.rb
+- lib/decision_agent/dmn/feel/types.rb
+- lib/decision_agent/dmn/importer.rb
+- lib/decision_agent/dmn/model.rb
+- lib/decision_agent/dmn/parser.rb
+- lib/decision_agent/dmn/testing.rb
+- lib/decision_agent/dmn/validator.rb
+- lib/decision_agent/dmn/versioning.rb
+- lib/decision_agent/dmn/visualizer.rb
 - lib/decision_agent/dsl/condition_evaluator.rb
 - lib/decision_agent/dsl/rule_parser.rb
 - lib/decision_agent/dsl/schema_validator.rb
@@ -181,6 +228,7 @@ files:
 - lib/decision_agent/evaluation.rb
 - lib/decision_agent/evaluation_validator.rb
 - lib/decision_agent/evaluators/base.rb
+- lib/decision_agent/evaluators/dmn_evaluator.rb
 - lib/decision_agent/evaluators/json_rule_evaluator.rb
 - lib/decision_agent/evaluators/static_evaluator.rb
 - lib/decision_agent/monitoring/alert_manager.rb
@@ -210,10 +258,14 @@ files:
 - lib/decision_agent/versioning/adapter.rb
 - lib/decision_agent/versioning/file_storage_adapter.rb
 - lib/decision_agent/versioning/version_manager.rb
+- lib/decision_agent/web/dmn_editor.rb
 - lib/decision_agent/web/middleware/auth_middleware.rb
 - lib/decision_agent/web/middleware/permission_middleware.rb
 - lib/decision_agent/web/public/app.js
 - lib/decision_agent/web/public/batch_testing.html
+- lib/decision_agent/web/public/dmn-editor.css
+- lib/decision_agent/web/public/dmn-editor.html
+- lib/decision_agent/web/public/dmn-editor.js
 - lib/decision_agent/web/public/index.html
 - lib/decision_agent/web/public/login.html
 - lib/decision_agent/web/public/styles.css
@@ -260,12 +312,25 @@ files:
 - spec/context_spec.rb
 - spec/decision_agent_spec.rb
 - spec/decision_spec.rb
+- spec/dmn/decision_graph_spec.rb
+- spec/dmn/decision_tree_spec.rb
+- spec/dmn/feel/errors_spec.rb
+- spec/dmn/feel/functions_spec.rb
+- spec/dmn/feel/simple_parser_spec.rb
+- spec/dmn/feel/types_spec.rb
+- spec/dmn/feel_parser_spec.rb
+- spec/dmn/hit_policy_spec.rb
+- spec/dmn/integration_spec.rb
 - spec/dsl/condition_evaluator_spec.rb
 - spec/dsl_validation_spec.rb
 - spec/edge_cases_spec.rb
 - spec/evaluation_spec.rb
 - spec/evaluation_validator_spec.rb
+- spec/examples.txt
 - spec/examples/feedback_aware_evaluator_spec.rb
+- spec/fixtures/dmn/complex_decision.dmn
+- spec/fixtures/dmn/invalid_structure.dmn
+- spec/fixtures/dmn/simple_decision.dmn
 - spec/issue_verification_spec.rb
 - spec/json_rule_evaluator_spec.rb
 - spec/monitoring/alert_manager_spec.rb