Add basic specs

Author: Taucher2003

gem/spec/spec_helper.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
 require 'triangulum'
+require 'tucana'
+
+Tucana.load_protocol(:shared)
+
+Dir[File.join(__dir__, 'support/**/*.rb')].each { |f| require f }
 
 RSpec.configure do |config|
-  # Enable flags like --only-failures and --next-failure
   config.example_status_persistence_file_path = '.rspec_status'
-
-  # Disable RSpec exposing methods globally on `Module` and `main`
   config.disable_monkey_patching!
+  config.include ProtobufFactories
 
   config.expect_with :rspec do |c|
     c.syntax = :expect

gem/spec/support/protobuf_factories.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module ProtobufFactories
+  def build_flow(node_functions:, starting_node_id: 1)
+    Tucana::Shared::ValidationFlow.new(
+      flow_id: 1,
+      project_id: 1,
+      type: 'test',
+      starting_node_id: starting_node_id,
+      node_functions: node_functions,
+      project_slug: 'test'
+    )
+  end
+
+  def literal_value(value)
+    Tucana::Shared::NodeValue.new(
+      literal_value: Tucana::Shared::Value.from_ruby(value)
+    )
+  end
+
+  def reference_node(node_id:, paths: [])
+    Tucana::Shared::NodeValue.new(
+      reference_value: Tucana::Shared::ReferenceValue.new(
+        node_id: node_id,
+        paths: paths
+      )
+    )
+  end
+
+  def node_function_value(node_id)
+    Tucana::Shared::NodeValue.new(node_function_id: node_id)
+  end
+
+  def node(id:, function_id:, parameters: [], next_node_id: nil)
+    Tucana::Shared::NodeFunction.new(
+      database_id: id,
+      runtime_function_id: function_id,
+      parameters: parameters,
+      next_node_id: next_node_id,
+      definition_source: 'test'
+    )
+  end
+
+  def param(id:, runtime_parameter_id:, value: nil)
+    Tucana::Shared::NodeParameter.new(
+      database_id: id,
+      runtime_parameter_id: runtime_parameter_id,
+      value: value
+    )
+  end
+
+  def default_data_types
+    [
+      Tucana::Shared::DefinitionDataType.new(identifier: 'LIST', type: 'T[]', generic_keys: ['T']),
+      Tucana::Shared::DefinitionDataType.new(identifier: 'NUMBER', type: 'number'),
+      Tucana::Shared::DefinitionDataType.new(identifier: 'STRING', type: 'string'),
+      Tucana::Shared::DefinitionDataType.new(identifier: 'CONSUMER', type: '(item:R) => void', generic_keys: ['R']),
+      Tucana::Shared::DefinitionDataType.new(identifier: 'RUNNABLE', type: '() => void')
+    ]
+  end
+
+  def default_functions
+    [
+      Tucana::Shared::RuntimeFunctionDefinition.new(
+        runtime_name: 'std::math::add',
+        signature: '(a: NUMBER, b: NUMBER): NUMBER'
+      ),
+      Tucana::Shared::RuntimeFunctionDefinition.new(
+        runtime_name: 'std::list::at',
+        signature: '<R>(list: LIST<R>, index: NUMBER): R'
+      ),
+      Tucana::Shared::RuntimeFunctionDefinition.new(
+        runtime_name: 'std::control::for_each',
+        signature: '<R>(list: LIST<R>, consumer: CONSUMER<R>): void'
+      ),
+      Tucana::Shared::RuntimeFunctionDefinition.new(
+        runtime_name: 'std::control::return',
+        signature: '<R>(value: R): R'
+      )
+    ]
+  end
+end

gem/spec/triangulum/validation_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+RSpec.describe Triangulum::Validation do
+  let(:data_types) { default_data_types }
+  let(:functions) { default_functions }
+
+  describe '#validate' do
+    it 'validates a simple valid flow' do
+      flow = build_flow(
+        node_functions: [
+          node(
+            id: 1,
+            function_id: 'std::math::add',
+            parameters: [
+              param(id: 1, runtime_parameter_id: 'a', value: literal_value(1)),
+              param(id: 2, runtime_parameter_id: 'b', value: literal_value(0))
+            ]
+          )
+        ]
+      )
+
+      result = described_class.new(flow, functions, data_types).validate
+
+      expect(result.valid?).to be true
+      expect(result.diagnostics).to be_empty
+    end
+
+    it 'detects type errors in parameters' do
+      flow = build_flow(
+        node_functions: [
+          node(
+            id: 1,
+            function_id: 'std::math::add',
+            parameters: [
+              param(id: 1, runtime_parameter_id: 'a', value: literal_value('not a number')),
+              param(id: 2, runtime_parameter_id: 'b', value: literal_value(10))
+            ]
+          )
+        ]
+      )
+
+      result = described_class.new(flow, functions, data_types).validate
+
+      expect(result.valid?).to be false
+      expect(result.diagnostics).not_to be_empty
+      expect(result.diagnostics.first.message).to include('number')
+    end
+
+    it 'validates a flow with references between nodes' do
+      flow = build_flow(
+        node_functions: [
+          node(
+            id: 1,
+            function_id: 'std::math::add',
+            next_node_id: 2,
+            parameters: [
+              param(id: 1, runtime_parameter_id: 'a', value: literal_value(1)),
+              param(id: 2, runtime_parameter_id: 'b', value: literal_value(2))
+            ]
+          ),
+          node(
+            id: 2,
+            function_id: 'std::math::add',
+            parameters: [
+              param(id: 3, runtime_parameter_id: 'a', value: reference_node(node_id: 1)),
+              param(id: 4, runtime_parameter_id: 'b', value: literal_value(3))
+            ]
+          )
+        ]
+      )
+
+      result = described_class.new(flow, functions, data_types).validate
+
+      expect(result.valid?).to be true
+      expect(result.diagnostics).to be_empty
+    end
+
+    it 'validates a flow with nested scopes' do
+      flow = build_flow(
+        node_functions: [
+          node(
+            id: 1,
+            function_id: 'std::control::for_each',
+            parameters: [
+              param(id: 1, runtime_parameter_id: 'list', value: literal_value([1, 2, 3])),
+              param(id: 2, runtime_parameter_id: 'consumer', value: node_function_value(2))
+            ]
+          ),
+          node(
+            id: 2,
+            function_id: 'std::math::add',
+            parameters: [
+              param(id: 3, runtime_parameter_id: 'a', value: literal_value(1)),
+              param(id: 4, runtime_parameter_id: 'b', value: literal_value(2))
+            ]
+          )
+        ]
+      )
+
+      result = described_class.new(flow, functions, data_types).validate
+
+      expect(result.valid?).to be true
+    end
+
+    it 'returns diagnostics with node_id and parameter_index' do
+      flow = build_flow(
+        node_functions: [
+          node(
+            id: 1,
+            function_id: 'std::math::add',
+            parameters: [
+              param(id: 1, runtime_parameter_id: 'a', value: literal_value('string')),
+              param(id: 2, runtime_parameter_id: 'b', value: literal_value(10))
+            ]
+          )
+        ]
+      )
+
+      result = described_class.new(flow, functions, data_types).validate
+
+      expect(result.valid?).to be false
+      diagnostic = result.diagnostics.find { |d| d.parameter_index == 0 }
+      expect(diagnostic).not_to be_nil
+      expect(diagnostic.node_id).not_to be_nil
+    end
+
+    it 'returns the return type' do
+      flow = build_flow(
+        node_functions: [
+          node(
+            id: 1,
+            function_id: 'std::math::add',
+            parameters: [
+              param(id: 1, runtime_parameter_id: 'a', value: literal_value(1)),
+              param(id: 2, runtime_parameter_id: 'b', value: literal_value(2))
+            ]
+          )
+        ]
+      )
+
+      result = described_class.new(flow, functions, data_types).validate
+
+      expect(result.return_type).to eq('void')
+    end
+  end
+end