jsonstructure 0.5.1

data/spec/test_assets_spec.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'json'
+
+# Test against the shared test-assets to ensure consistency with other SDKs
+RSpec.describe 'Test Assets Conformance' do
+  # Find test-assets directory relative to this file
+  def find_test_assets_path
+    current = File.dirname(__FILE__)
+    
+    # Try different relative paths
+    candidates = [
+      File.join(current, '..', '..', 'test-assets'),
+      File.join(current, '..', '..', '..', 'test-assets'),
+      File.join(current, '..', '..', 'sdk', 'test-assets')
+    ]
+    
+    candidates.each do |path|
+      expanded = File.expand_path(path)
+      return expanded if File.directory?(expanded)
+    end
+    
+    nil
+  end
+
+  let(:test_assets_path) { find_test_assets_path }
+
+  before do
+    skip 'test-assets directory not found' unless test_assets_path
+  end
+
+  describe 'Invalid Schemas' do
+    let(:invalid_schemas_path) { File.join(test_assets_path, 'schemas', 'invalid') }
+
+    it 'rejects all invalid schemas' do
+      skip 'invalid schemas directory not found' unless File.directory?(invalid_schemas_path)
+
+      schema_files = Dir.glob(File.join(invalid_schemas_path, '*.struct.json'))
+      skip 'no invalid schema files found' if schema_files.empty?
+
+      passed = 0
+      failed = []
+
+      schema_files.each do |file|
+        schema_content = File.read(file)
+        result = JsonStructure::SchemaValidator.validate(schema_content)
+
+        if result.invalid?
+          passed += 1
+        else
+          failed << File.basename(file)
+        end
+      end
+
+      expect(failed).to be_empty,
+        "Expected these schemas to be invalid but they were valid: #{failed.join(', ')}"
+      
+      puts "  Tested #{passed} invalid schemas - all correctly rejected"
+    end
+  end
+
+  describe 'Valid Schemas (validation extension)' do
+    let(:valid_schemas_path) { File.join(test_assets_path, 'schemas', 'validation') }
+
+    it 'accepts all validation extension schemas' do
+      skip 'validation schemas directory not found' unless File.directory?(valid_schemas_path)
+
+      schema_files = Dir.glob(File.join(valid_schemas_path, '*.struct.json'))
+      skip 'no validation schema files found' if schema_files.empty?
+
+      passed = 0
+      failed = []
+
+      schema_files.each do |file|
+        schema_content = File.read(file)
+        result = JsonStructure::SchemaValidator.validate(schema_content)
+
+        # Check for errors only, warnings are acceptable
+        errors = result.errors.select { |e| e.severity == :error }
+        if errors.empty?
+          passed += 1
+        else
+          failed << "#{File.basename(file)}: #{result.error_messages.join(', ')}"
+        end
+      end
+
+      expect(failed).to be_empty,
+        "Expected these schemas to be valid but got errors:\n  #{failed.join("\n  ")}"
+      
+      puts "  Tested #{passed} validation schemas - all accepted"
+    end
+  end
+
+  describe 'Instance Validation against test schemas' do
+    let(:validation_instances_path) { File.join(test_assets_path, 'instances', 'validation') }
+    let(:validation_schemas_path) { File.join(test_assets_path, 'schemas', 'validation') }
+
+    # Helper to extract the actual value from a test instance
+    # Test instances may have metadata fields like _description, _expectedError, _comment
+    # These need to be stripped before validation, or use the "value" field if present
+    def extract_instance_value(instance_json)
+      instance = JSON.parse(instance_json)
+      
+      # If there's a "value" field, use that
+      return JSON.generate(instance['value']) if instance.key?('value')
+      
+      # Otherwise, remove metadata fields and use the rest
+      instance.delete('_description')
+      instance.delete('_expectedError')
+      instance.delete('_comment')
+      JSON.generate(instance)
+    end
+
+    it 'rejects invalid instances against their schemas' do
+      skip 'validation instances directory not found' unless File.directory?(validation_instances_path)
+
+      # Each schema has a corresponding directory with invalid instances
+      schema_dirs = Dir.glob(File.join(validation_instances_path, '*')).select { |f| File.directory?(f) }
+      skip 'no instance directories found' if schema_dirs.empty?
+
+      passed = 0
+      failed = []
+
+      schema_dirs.each do |instance_dir|
+        schema_name = File.basename(instance_dir)
+        schema_file = File.join(validation_schemas_path, "#{schema_name}.struct.json")
+        
+        next unless File.exist?(schema_file)
+
+        schema_content = File.read(schema_file)
+
+        # Test invalid instances (files directly in the schema's instance directory)
+        instance_files = Dir.glob(File.join(instance_dir, '*.json'))
+        instance_files.each do |instance_file|
+          instance_content = File.read(instance_file)
+          # Extract the actual value, stripping metadata fields
+          instance_value = extract_instance_value(instance_content)
+          result = JsonStructure::InstanceValidator.validate(instance_value, schema_content)
+
+          if result.invalid?
+            passed += 1
+          else
+            failed << "#{schema_name}/#{File.basename(instance_file)}"
+          end
+        end
+      end
+
+      expect(failed).to be_empty,
+        "Expected these instances to be invalid but they were valid:\n  #{failed.join("\n  ")}"
+      
+      puts "  Tested #{passed} invalid instances - all correctly rejected"
+    end
+  end
+
+  describe 'Primer sample schemas' do
+    def find_primer_samples_path
+      current = File.dirname(__FILE__)
+      
+      candidates = [
+        File.join(current, '..', '..', 'primer-and-samples', 'samples', 'core'),
+        File.join(current, '..', '..', '..', 'primer-and-samples', 'samples', 'core')
+      ]
+      
+      candidates.each do |path|
+        expanded = File.expand_path(path)
+        return expanded if File.directory?(expanded)
+      end
+      
+      nil
+    end
+
+    let(:primer_path) { find_primer_samples_path }
+
+    it 'accepts all primer sample schemas' do
+      skip 'primer samples directory not found' unless primer_path
+
+      # Find all .struct.json files recursively
+      schema_files = Dir.glob(File.join(primer_path, '**', '*.struct.json'))
+      skip 'no primer schema files found' if schema_files.empty?
+
+      passed = 0
+      failed = []
+
+      schema_files.each do |file|
+        schema_content = File.read(file)
+        result = JsonStructure::SchemaValidator.validate(schema_content)
+
+        # Check for errors only
+        errors = result.errors.select { |e| e.severity == :error }
+        if errors.empty?
+          passed += 1
+        else
+          relative_path = file.sub(primer_path + '/', '')
+          failed << "#{relative_path}: #{result.error_messages.join(', ')}"
+        end
+      end
+
+      expect(failed).to be_empty,
+        "Expected these primer schemas to be valid but got errors:\n  #{failed.join("\n  ")}"
+      
+      puts "  Tested #{passed} primer sample schemas - all accepted"
+    end
+  end
+end

data/spec/thread_safety_spec.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Thread Safety' do
+  let(:valid_schema) { '{"type": "object", "properties": {"name": {"type": "string"}}}' }
+  let(:valid_instance) { '{"name": "test"}' }
+  let(:invalid_instance) { '{"name": 123}' }
+
+  describe 'concurrent schema validation' do
+    it 'handles multiple threads validating schemas concurrently' do
+      thread_count = 10
+      iterations = 50
+      errors = []
+      mutex = Mutex.new
+
+      threads = thread_count.times.map do |thread_id|
+        Thread.new do
+          iterations.times do |i|
+            begin
+              result = JsonStructure::SchemaValidator.validate(valid_schema)
+              unless result.valid?
+                mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i}: expected valid, got invalid" }
+              end
+            rescue => e
+              mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i}: #{e.class} - #{e.message}" }
+            end
+          end
+        end
+      end
+
+      threads.each(&:join)
+      expect(errors).to be_empty, "Errors occurred during concurrent validation:\n#{errors.join("\n")}"
+    end
+
+    it 'handles mixed valid and invalid schemas concurrently' do
+      thread_count = 10
+      iterations = 20
+      errors = []
+      mutex = Mutex.new
+
+      schemas = [
+        { json: '{"type": "string"}', valid: true },
+        { json: '{"type": "invalid_type"}', valid: false },
+        { json: '{"type": "object", "properties": {"a": {"type": "integer"}}}', valid: true },
+        { json: '{"minimum": "not_a_number"}', valid: false }
+      ]
+
+      threads = thread_count.times.map do |thread_id|
+        Thread.new do
+          iterations.times do |i|
+            schema_info = schemas[(thread_id + i) % schemas.length]
+            begin
+              result = JsonStructure::SchemaValidator.validate(schema_info[:json])
+              if result.valid? != schema_info[:valid]
+                mutex.synchronize do
+                  errors << "Thread #{thread_id}, iteration #{i}: expected #{schema_info[:valid]}, got #{result.valid?}"
+                end
+              end
+            rescue => e
+              mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i}: #{e.class} - #{e.message}" }
+            end
+          end
+        end
+      end
+
+      threads.each(&:join)
+      expect(errors).to be_empty, "Errors occurred during concurrent validation:\n#{errors.join("\n")}"
+    end
+  end
+
+  describe 'concurrent instance validation' do
+    it 'handles multiple threads validating instances concurrently' do
+      thread_count = 10
+      iterations = 50
+      errors = []
+      mutex = Mutex.new
+
+      threads = thread_count.times.map do |thread_id|
+        Thread.new do
+          iterations.times do |i|
+            begin
+              result = JsonStructure::InstanceValidator.validate(valid_instance, valid_schema)
+              unless result.valid?
+                mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i}: expected valid, got invalid" }
+              end
+            rescue => e
+              mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i}: #{e.class} - #{e.message}" }
+            end
+          end
+        end
+      end
+
+      threads.each(&:join)
+      expect(errors).to be_empty, "Errors occurred during concurrent validation:\n#{errors.join("\n")}"
+    end
+
+    it 'handles mixed valid and invalid instances concurrently' do
+      thread_count = 10
+      iterations = 20
+      errors = []
+      mutex = Mutex.new
+
+      test_cases = [
+        { instance: '{"name": "Alice"}', valid: true },
+        { instance: '{"name": 123}', valid: false },
+        { instance: '{"name": "Bob", "age": 30}', valid: true },
+        { instance: '{}', valid: true }
+      ]
+
+      threads = thread_count.times.map do |thread_id|
+        Thread.new do
+          iterations.times do |i|
+            test_case = test_cases[(thread_id + i) % test_cases.length]
+            begin
+              result = JsonStructure::InstanceValidator.validate(test_case[:instance], valid_schema)
+              if result.valid? != test_case[:valid]
+                mutex.synchronize do
+                  errors << "Thread #{thread_id}, iteration #{i}: expected #{test_case[:valid]}, got #{result.valid?}"
+                end
+              end
+            rescue => e
+              mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i}: #{e.class} - #{e.message}" }
+            end
+          end
+        end
+      end
+
+      threads.each(&:join)
+      expect(errors).to be_empty, "Errors occurred during concurrent validation:\n#{errors.join("\n")}"
+    end
+  end
+
+  describe 'mixed concurrent operations' do
+    it 'handles schema and instance validations running concurrently' do
+      thread_count = 10
+      iterations = 30
+      errors = []
+      mutex = Mutex.new
+
+      threads = thread_count.times.map do |thread_id|
+        Thread.new do
+          iterations.times do |i|
+            begin
+              if i.even?
+                # Schema validation
+                result = JsonStructure::SchemaValidator.validate(valid_schema)
+                unless result.valid?
+                  mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i} (schema): expected valid" }
+                end
+              else
+                # Instance validation
+                result = JsonStructure::InstanceValidator.validate(valid_instance, valid_schema)
+                unless result.valid?
+                  mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i} (instance): expected valid" }
+                end
+              end
+            rescue => e
+              mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i}: #{e.class} - #{e.message}" }
+            end
+          end
+        end
+      end
+
+      threads.each(&:join)
+      expect(errors).to be_empty, "Errors occurred during concurrent validation:\n#{errors.join("\n")}"
+    end
+  end
+
+  describe 'validation tracking' do
+    it 'properly tracks active validations' do
+      # Initially no validations should be active
+      expect(JsonStructure.validations_active?).to be false
+    end
+
+    it 'handles validation_started and validation_completed correctly' do
+      # Start a validation
+      JsonStructure.validation_started
+      expect(JsonStructure.validations_active?).to be true
+
+      # Complete the validation
+      JsonStructure.validation_completed
+      expect(JsonStructure.validations_active?).to be false
+    end
+
+    it 'handles multiple concurrent validation tracking' do
+      # Start multiple validations
+      5.times { JsonStructure.validation_started }
+      expect(JsonStructure.validations_active?).to be true
+
+      # Complete them all
+      5.times { JsonStructure.validation_completed }
+      expect(JsonStructure.validations_active?).to be false
+    end
+  end
+
+  describe 'stress test' do
+    it 'survives high-concurrency stress test' do
+      thread_count = 20
+      iterations = 100
+      errors = []
+      mutex = Mutex.new
+
+      schemas = [
+        '{"type": "string"}',
+        '{"type": "integer", "minimum": 0}',
+        '{"type": "object", "properties": {"id": {"type": "integer"}}}',
+        '{"type": "array", "items": {"type": "string"}}'
+      ]
+
+      instances = [
+        ['"hello"', '{"type": "string"}', true],
+        ['42', '{"type": "integer", "minimum": 0}', true],
+        ['{"id": 123}', '{"type": "object", "properties": {"id": {"type": "integer"}}}', true],
+        ['["a", "b", "c"]', '{"type": "array", "items": {"type": "string"}}', true],
+        ['"hello"', '{"type": "integer"}', false],
+        ['-5', '{"type": "integer", "minimum": 0}', false]
+      ]
+
+      threads = thread_count.times.map do |thread_id|
+        Thread.new do
+          iterations.times do |i|
+            begin
+              case i % 3
+              when 0
+                # Schema validation
+                schema = schemas[rand(schemas.length)]
+                JsonStructure::SchemaValidator.validate(schema)
+              when 1
+                # Instance validation with expected result
+                instance_info = instances[rand(instances.length)]
+                result = JsonStructure::InstanceValidator.validate(instance_info[0], instance_info[1])
+                if result.valid? != instance_info[2]
+                  mutex.synchronize do
+                    errors << "Thread #{thread_id}, iteration #{i}: unexpected result for #{instance_info[0]}"
+                  end
+                end
+              when 2
+                # validate! with exception handling
+                begin
+                  JsonStructure::SchemaValidator.validate!('{"type": "string"}')
+                rescue JsonStructure::SchemaValidationError
+                  mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i}: unexpected exception" }
+                end
+              end
+            rescue => e
+              mutex.synchronize { errors << "Thread #{thread_id}, iteration #{i}: #{e.class} - #{e.message}" }
+            end
+          end
+        end
+      end
+
+      threads.each(&:join)
+      expect(errors).to be_empty, "Errors occurred during stress test:\n#{errors.first(10).join("\n")}"
+    end
+  end
+end

data/spec/validation_result_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe JsonStructure::ValidationResult do
+  describe '#valid?' do
+    it 'returns true for valid result' do
+      result = described_class.new(true, [])
+      expect(result).to be_valid
+    end
+
+    it 'returns false for invalid result' do
+      result = described_class.new(false, [])
+      expect(result).to be_invalid
+    end
+  end
+
+  describe '#errors' do
+    it 'returns empty array for valid result' do
+      result = described_class.new(true, [])
+      expect(result.errors).to be_empty
+    end
+
+    it 'returns error array for invalid result' do
+      error = JsonStructure::ValidationError.new(
+        code: 1,
+        severity: JsonStructure::FFI::JS_SEVERITY_ERROR,
+        path: '/test',
+        message: 'Test error',
+        location: { line: 1, column: 1, offset: 0 }
+      )
+      result = described_class.new(false, [error])
+
+      expect(result.errors).not_to be_empty
+      expect(result.errors.first).to be_a(JsonStructure::ValidationError)
+    end
+  end
+
+  describe '#error_messages' do
+    it 'returns only error-level messages' do
+      errors = [
+        JsonStructure::ValidationError.new(
+          code: 1,
+          severity: JsonStructure::FFI::JS_SEVERITY_ERROR,
+          path: '/test',
+          message: 'Error message',
+          location: { line: 1, column: 1, offset: 0 }
+        ),
+        JsonStructure::ValidationError.new(
+          code: 2,
+          severity: JsonStructure::FFI::JS_SEVERITY_WARNING,
+          path: '/test',
+          message: 'Warning message',
+          location: { line: 1, column: 1, offset: 0 }
+        )
+      ]
+      result = described_class.new(false, errors)
+
+      expect(result.error_messages).to eq(['Error message'])
+    end
+  end
+
+  describe '#warning_messages' do
+    it 'returns only warning-level messages' do
+      errors = [
+        JsonStructure::ValidationError.new(
+          code: 1,
+          severity: JsonStructure::FFI::JS_SEVERITY_ERROR,
+          path: '/test',
+          message: 'Error message',
+          location: { line: 1, column: 1, offset: 0 }
+        ),
+        JsonStructure::ValidationError.new(
+          code: 2,
+          severity: JsonStructure::FFI::JS_SEVERITY_WARNING,
+          path: '/test',
+          message: 'Warning message',
+          location: { line: 1, column: 1, offset: 0 }
+        )
+      ]
+      result = described_class.new(false, errors)
+
+      expect(result.warning_messages).to eq(['Warning message'])
+    end
+  end
+end
+
+RSpec.describe JsonStructure::ValidationError do
+  describe '#error?' do
+    it 'returns true for error severity' do
+      error = described_class.new(
+        code: 1,
+        severity: JsonStructure::FFI::JS_SEVERITY_ERROR,
+        path: '/test',
+        message: 'Test',
+        location: { line: 1, column: 1, offset: 0 }
+      )
+
+      expect(error).to be_error
+    end
+
+    it 'returns false for non-error severity' do
+      warning = described_class.new(
+        code: 1,
+        severity: JsonStructure::FFI::JS_SEVERITY_WARNING,
+        path: '/test',
+        message: 'Test',
+        location: { line: 1, column: 1, offset: 0 }
+      )
+
+      expect(warning).not_to be_error
+    end
+  end
+
+  describe '#warning?' do
+    it 'returns true for warning severity' do
+      warning = described_class.new(
+        code: 1,
+        severity: JsonStructure::FFI::JS_SEVERITY_WARNING,
+        path: '/test',
+        message: 'Test',
+        location: { line: 1, column: 1, offset: 0 }
+      )
+
+      expect(warning).to be_warning
+    end
+  end
+
+  describe '#to_s' do
+    it 'includes path when present' do
+      error = described_class.new(
+        code: 1,
+        severity: JsonStructure::FFI::JS_SEVERITY_ERROR,
+        path: '/test/path',
+        message: 'Test error',
+        location: { line: 1, column: 1, offset: 0 }
+      )
+
+      expect(error.to_s).to include('Test error')
+      expect(error.to_s).to include('/test/path')
+    end
+
+    it 'works without path' do
+      error = described_class.new(
+        code: 1,
+        severity: JsonStructure::FFI::JS_SEVERITY_ERROR,
+        path: nil,
+        message: 'Test error',
+        location: { line: 1, column: 1, offset: 0 }
+      )
+
+      expect(error.to_s).to eq('Test error')
+    end
+  end
+end