testeranto.rubeno 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ab099109b1366b88ab8e8a7a5fbf951ade16dfd50b34f0020fcc892c545f745
+  data.tar.gz: 6b3cbdcf603218bbbb778b42117065aac703fc94c91da7dc522ce4647e9e4871
+SHA512:
+  metadata.gz: b7aa0c61d50e39e90ec39eb4ed1e923cfffdd4a3a5168408f0185d8363869fe4cc15a00ef8590cf4b670c9066b71dd1993812ae38afb4e14afde99ce0161eb1e
+  data.tar.gz: 572789fa5f684ffdb6df784c6c21ed42097bcf351f82f23ee6bee2aa4b0eb29644220a2f83197f36a9e7496feae7a030ca7c7e5196f62ed8e8a9eebc0ed505cf

data/README.md

@@ -0,0 +1,122 @@
+# Rubeno
+
+The Ruby implementation of Testeranto.
+
+## Deployment to rubygems
+1) update the version in rubeno.gemspec
+2) `gem build rubeno.gemspec`
+
+## Overview
+
+Rubeno is a Ruby implementation of the Testeranto BDD testing framework. It follows the same patterns as the other language implementations (TypeScript, Python, Go) to provide a consistent testing experience across multiple programming languages.
+
+## Structure
+
+The implementation consists of:
+
+1. **Base Classes**: `BaseSuite`, `BaseGiven`, `BaseWhen`, `BaseThen` - Core BDD components
+2. **Main Class**: `Rubeno` - Orchestrates test execution
+3. **Test Adapter**: `SimpleTestAdapter` - Default adapter implementation
+4. **Process Manager**: `PM_Ruby` - Handles communication
+5. **Types**: Type definitions for the framework
+
+## Usage
+
+### Basic Example
+
+```ruby
+require 'rubeno'
+
+# Define test implementation
+test_implementation = Rubeno::ITestImplementation.new(
+  suites: { 'Default' => ->(name, givens) { ... } },
+  givens: { 'basic' => ->(initial_values) { ... } },
+  whens: { 'press' => ->(button) { ->(store) { ... } } },
+  thens: { 'displayIs' => ->(expected) { ->(store) { ... } } }
+)
+
+# Define test specification
+test_specification = ->(suites, givens, whens, thens) do
+  [
+    suites.Default('Test Suite', {
+      'test1' => givens.basic([], [whens.press('1')], [thens.displayIs('1')], nil)
+    })
+  ]
+end
+
+# Create test instance
+test_instance = Rubeno.Rubeno(
+  nil,
+  test_specification,
+  test_implementation,
+  Rubeno::SimpleTestAdapter.new,
+  Rubeno::ITTestResourceRequest.new(ports: 1)
+)
+
+# Set as default and run
+Rubeno.set_default_instance(test_instance)
+Rubeno.main
+```
+
+### Running Tests
+
+To run tests with Rubeno:
+
+```bash
+ruby example/Calculator-test.rb '{"name":"test","fs":".","ports":[]}'
+```
+
+## Integration with Testeranto
+
+Rubeno follows the same patterns as other Testeranto implementations:
+
+1. **Test Resource Configuration**: Passed as a JSON string argument
+2. **Results Output**: Writes to `testeranto/reports/example/ruby.Calculator.test.ts.json`
+3. **WebSocket Communication**: Supports communication via WebSocket (when configured)
+4. **Artifact Generation**: Supports test artifacts and reporting
+
+## Docker Support
+
+Rubeno includes a Dockerfile for running tests in containers:
+
+```dockerfile
+FROM ruby:3.2-alpine
+WORKDIR /workspace
+# ... (see testeranto/runtimes/ruby/ruby.Dockerfile)
+```
+
+## Extending
+
+To create custom adapters, implement the `ITestAdapter` module:
+
+```ruby
+class CustomAdapter
+  include Rubeno::ITestAdapter
+  
+  def before_all(input_val, tr, pm)
+    # Custom setup
+    input_val
+  end
+  
+  # ... implement other methods
+end
+```
+
+## Dependencies
+
+- Ruby 2.7+ (for pattern matching and other modern features)
+- JSON (standard library)
+
+## Future Enhancements
+
+1. **WebSocket Support**: Full WebSocket communication for real-time test reporting
+2. **Advanced Adapters**: More sophisticated adapter implementations
+3. **Plugin System**: Extensible plugin architecture
+4. **Performance Optimizations**: Improved test execution performance
+
+## See Also
+
+- [Tiposkripto](../tiposkripto/) - TypeScript/JavaScript implementation
+- [Pitono](../pitono/) - Python implementation
+- [Golingvu](../golingvu/) - Go implementation
+

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/rubeno

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rubeno'
+
+Rubeno.main

data/lib/base_given.rb

@@ -0,0 +1,137 @@
+module Rubeno
+  class BaseGiven
+    attr_accessor :features, :whens, :thens, :error, :fail, :store, :recommended_fs_path,
+                  :given_cb, :initial_values, :key, :failed, :artifacts, :status, :fails
+    
+    def initialize(features, whens, thens, given_cb, initial_values, adapter = nil)
+      @features = features
+      @whens = whens
+      @thens = thens
+      @given_cb = given_cb
+      @initial_values = initial_values
+      @adapter = adapter
+      @artifacts = []
+      @fails = 0
+    end
+    
+    def add_artifact(path)
+      normalized_path = path.gsub('\\', '/')
+      @artifacts << normalized_path
+    end
+    
+    def before_all(store)
+      store
+    end
+    
+    def to_obj
+      {
+        key: @key,
+        whens: (@whens || []).map { |w| w.respond_to?(:to_obj) ? w.to_obj : {} },
+        thens: (@thens || []).map { |t| t.respond_to?(:to_obj) ? t.to_obj : {} },
+        error: @error ? [@error, @error.backtrace] : nil,
+        failed: @failed,
+        features: @features || [],
+        artifacts: @artifacts,
+        status: @status
+      }
+    end
+    
+    def given_that(subject, test_resource_configuration, artifactory, given_cb, initial_values, pm)
+      # Use the adapter's before_each method if available
+      if @adapter
+        @adapter.before_each(subject, given_cb, test_resource_configuration, initial_values, pm)
+      else
+        # Fallback to just returning the subject
+        subject
+      end
+    end
+    
+    def after_each(store, key, artifactory, pm)
+      store
+    end
+    
+    def give(subject, key, test_resource_configuration, tester, artifactory, t_log, pm, suite_ndx)
+      @key = key
+      @fails = 0
+      @failed = false
+      @error = nil
+      
+      given_artifactory = ->(f_path, value) do
+        artifactory.call("given-#{key}/#{f_path}", value)
+      end
+      
+      begin
+        # Call the given callback to get initial subject
+        initial_subject = @given_cb.call(@initial_values)
+        @store = given_that(
+          initial_subject,
+          test_resource_configuration,
+          given_artifactory,
+          @given_cb,
+          @initial_values,
+          pm
+        )
+        @status = true
+      rescue => e
+        @status = false
+        @failed = true
+        @fails += 1
+        @error = e
+        return @store
+      end
+      
+      begin
+        # Process whens
+        @whens.each_with_index do |when_step, when_ndx|
+          begin
+            @store = when_step.test(
+              @store,
+              test_resource_configuration,
+              t_log,
+              pm,
+              "suite-#{suite_ndx}/given-#{key}/when/#{when_ndx}"
+            )
+          rescue => e
+            @failed = true
+            @fails += 1
+            @error = e
+          end
+        end
+        
+        # Process thens
+        @thens.each_with_index do |then_step, then_ndx|
+          begin
+            result = then_step.test(
+              @store,
+              test_resource_configuration,
+              t_log,
+              pm,
+              "suite-#{suite_ndx}/given-#{key}/then-#{then_ndx}"
+            )
+            unless tester.call(result)
+              @failed = true
+              @fails += 1
+            end
+          rescue => e
+            @failed = true
+            @fails += 1
+            @error = e
+          end
+        end
+      rescue => e
+        @error = e
+        @failed = true
+        @fails += 1
+      ensure
+        begin
+          after_each(@store, @key, given_artifactory, pm)
+        rescue => e
+          @failed = true
+          @fails += 1
+        end
+      end
+      
+      @store
+    end
+  end
+end

data/lib/base_suite.rb

@@ -0,0 +1,94 @@
+module Rubeno
+  class BaseSuite
+    attr_accessor :name, :givens, :store, :test_resource_configuration, :index, :failed, :fails, :artifacts
+    
+    def initialize(name, givens = {})
+      @name = name
+      @givens = givens
+      @artifacts = []
+      @failed = false
+      @fails = 0
+    end
+    
+    def add_artifact(path)
+      normalized_path = path.gsub('\\', '/')
+      @artifacts << normalized_path
+    end
+    
+    def features
+      features = []
+      seen = {}
+      @givens.each_value do |given|
+        given.features.each do |feature|
+          unless seen[feature]
+            features << feature
+            seen[feature] = true
+          end
+        end
+      end
+      features
+    end
+    
+    def to_obj
+      {
+        name: @name,
+        givens: @givens.values.map(&:to_obj),
+        fails: @fails,
+        failed: @failed,
+        features: features,
+        artifacts: @artifacts
+      }
+    end
+    
+    def setup(s, artifactory, tr, pm)
+      s
+    end
+    
+    def assert_that(t)
+      !!t
+    end
+    
+    def after_all(store, artifactory, pm)
+      store
+    end
+    
+    def run(input_val, test_resource_configuration, artifactory, t_log, pm)
+      @test_resource_configuration = test_resource_configuration
+      
+      subject = setup(input_val, artifactory, test_resource_configuration, pm)
+      
+      @fails = 0
+      @failed = false
+      
+      @givens.each do |g_key, g|
+        begin
+          @store = g.give(
+            subject,
+            g_key,
+            test_resource_configuration,
+            method(:assert_that),
+            artifactory,
+            t_log,
+            pm,
+            @index
+          )
+          @fails += g.fails if g.fails && g.fails > 0
+        rescue => e
+          @failed = true
+          @fails += 1
+          puts "Error in given #{g_key}: #{e.message}"
+        end
+      end
+      
+      @failed = true if @fails > 0
+      
+      begin
+        after_all(@store, artifactory, pm)
+      rescue => e
+        puts "Error in after_all: #{e.message}"
+      end
+      
+      self
+    end
+  end
+end

data/lib/base_then.rb

@@ -0,0 +1,44 @@
+module Rubeno
+  class BaseThen
+    attr_accessor :name, :then_cb, :error, :artifacts, :status
+    
+    def initialize(name, then_cb)
+      @name = name
+      @then_cb = then_cb
+      @error = false
+      @artifacts = []
+    end
+    
+    def add_artifact(path)
+      normalized_path = path.gsub('\\', '/')
+      @artifacts << normalized_path
+    end
+    
+    def but_then(store, then_cb, test_resource_configuration, pm)
+      # Call the then_cb directly
+      then_cb.call(store)
+    end
+    
+    def to_obj
+      {
+        name: @name,
+        error: @error,
+        artifacts: @artifacts,
+        status: @status
+      }
+    end
+    
+    def test(store, test_resource_configuration, t_log, pm, filepath)
+      begin
+        # Call the then_cb with the store to get a boolean result
+        result = @then_cb.call(store)
+        @status = true
+        result
+      rescue => e
+        @status = false
+        @error = true
+        raise e
+      end
+    end
+  end
+end

data/lib/base_when.rb

@@ -0,0 +1,47 @@
+module Rubeno
+  class BaseWhen
+    attr_accessor :name, :when_cb, :error, :artifacts, :status
+    
+    def initialize(name, when_cb)
+      @name = name
+      @when_cb = when_cb
+      @artifacts = []
+    end
+    
+    def add_artifact(path)
+      normalized_path = path.gsub('\\', '/')
+      @artifacts << normalized_path
+    end
+    
+    def and_when(store, when_cb, test_resource_configuration, pm)
+      # Call the when_cb directly
+      when_cb.call(store)
+    end
+    
+    def to_obj
+      error_str = nil
+      if @error
+        error_str = "#{@error.class}: #{@error.message}"
+      end
+      {
+        name: @name,
+        status: @status,
+        error: error_str,
+        artifacts: @artifacts
+      }
+    end
+    
+    def test(store, test_resource_configuration, t_log, pm, filepath)
+      begin
+        # Call the when_cb with the store
+        result = @when_cb.call(store)
+        @status = true
+        result
+      rescue => e
+        @status = false
+        @error = e
+        raise e
+      end
+    end
+  end
+end

data/lib/pm/ruby.rb

@@ -0,0 +1,156 @@
+module Rubeno
+  class PM_Ruby
+    def initialize(t, websocket_port)
+      @test_resource_configuration = t
+      @websocket_port = websocket_port
+      @connected = false
+    end
+    
+    def start
+      raise "DEPRECATED"
+    end
+    
+    def send(command, *args)
+      # For now, return default values to allow tests to run
+      case command
+      when "pages"
+        []
+      when "newPage"
+        "mock-page"
+      when "page"
+        "mock-page"
+      when "existsSync"
+        false
+      when "writeFileSync"
+        true
+      when "createWriteStream"
+        "mock-stream"
+      when "write"
+        true
+      when "end"
+        true
+      when "customclose"
+        nil
+      else
+        nil
+      end
+    end
+    
+    def pages
+      send("pages")
+    end
+    
+    def wait_for_selector(p, s)
+      send("waitForSelector", p, s)
+    end
+    
+    def close_page(p)
+      send("closePage", p)
+    end
+    
+    def goto(page, url)
+      send("goto", page, url)
+    end
+    
+    def new_page
+      send("newPage")
+    end
+    
+    def call(selector, page)
+      send("$", selector, page)
+    end
+    
+    def is_disabled(selector)
+      send("isDisabled", selector)
+    end
+    
+    def get_attribute(selector, attribute, p)
+      send("getAttribute", selector, attribute, p)
+    end
+    
+    def get_inner_html(selector, p)
+      send("getInnerHtml", selector, p)
+    end
+    
+    def focus_on(selector)
+      send("focusOn", selector)
+    end
+    
+    def type_into(selector)
+      send("typeInto", selector)
+    end
+    
+    def page
+      send("page")
+    end
+    
+    def click(selector)
+      send("click", selector)
+    end
+    
+    def screencast(opts, page)
+      adjusted_opts = opts.dup
+      if adjusted_opts['path']
+        adjusted_opts['path'] = "#{@test_resource_configuration.fs}/#{opts['path']}"
+      end
+      send("screencast", adjusted_opts, page, @test_resource_configuration.name)
+    end
+    
+    def screencast_stop(p)
+      send("screencastStop", p)
+    end
+    
+    def custom_screenshot(x)
+      opts = x[0]
+      page = x[1] if x.length > 1
+      
+      adjusted_opts = opts.dup
+      if adjusted_opts['path']
+        adjusted_opts['path'] = "#{@test_resource_configuration.fs}/#{opts['path']}"
+      end
+      
+      if page
+        send("customScreenShot", adjusted_opts, @test_resource_configuration.name, page)
+      else
+        send("customScreenShot", adjusted_opts, @test_resource_configuration.name)
+      end
+    end
+    
+    def exists_sync(dest_folder)
+      path = "#{@test_resource_configuration.fs}/#{dest_folder}"
+      send("existsSync", path)
+    end
+    
+    def mkdir_sync
+      path = "#{@test_resource_configuration.fs}/"
+      send("mkdirSync", path)
+    end
+    
+    def write(uid, contents)
+      send("write", uid, contents)
+    end
+    
+    def write_file_sync(filepath, contents)
+      full_path = "#{@test_resource_configuration.fs}/#{filepath}"
+      begin
+        result = send("writeFileSync", full_path, contents, @test_resource_configuration.name)
+        result
+      rescue => e
+        raise e
+      end
+    end
+    
+    def create_write_stream(filepath)
+      full_path = "#{@test_resource_configuration.fs}/#{filepath}"
+      send("createWriteStream", full_path, @test_resource_configuration.name)
+    end
+    
+    def end(uid)
+      send("end", uid)
+    end
+    
+    def custom_close
+      send("customclose", @test_resource_configuration.fs, @test_resource_configuration.name)
+    end
+  end
+end

data/lib/rubeno.rb

@@ -0,0 +1,379 @@
+require 'json'
+require 'base_suite'
+require 'base_given'
+require 'base_when'
+require 'base_then'
+require 'simple_adapter'
+require 'pm/ruby'
+require 'types'
+
+module Rubeno
+  class Rubeno
+    attr_accessor :test_resource_requirement, :artifacts, :test_jobs, :test_specification,
+                  :suites_overrides, :given_overrides, :when_overrides, :then_overrides,
+                  :puppet_master, :specs, :total_tests, :assert_this, :test_adapter,
+                  :test_subject
+    
+    def initialize(input_val, test_specification, test_implementation, test_resource_requirement, test_adapter, uber_catcher = nil)
+      @test_resource_requirement = test_resource_requirement
+      @artifacts = []
+      @test_jobs = []
+      @test_specification = test_specification
+      @suites_overrides = {}
+      @given_overrides = {}
+      @when_overrides = {}
+      @then_overrides = {}
+      @test_subject = input_val
+      @test_adapter = test_adapter
+      
+      # Initialize classy implementations
+      initialize_classy_implementations(test_implementation)
+      
+      # Generate specs
+      @specs = test_specification.call(
+        suites_wrapper,
+        given_wrapper,
+        when_wrapper,
+        then_wrapper
+      )
+      
+      # Initialize test jobs
+      initialize_test_jobs
+    end
+    
+    def suites_wrapper
+      # Return an object that responds to method calls for suite types
+      wrapper = Object.new
+      @suites_overrides.each do |suite_name, suite_proc|
+        wrapper.define_singleton_method(suite_name) do |description, givens_dict|
+          {
+            'name' => description,
+            'givens' => givens_dict
+          }
+        end
+      end
+      wrapper
+    end
+    
+    def given_wrapper
+      wrapper = Object.new
+      @given_overrides.each do |given_name, given_proc|
+        wrapper.define_singleton_method(given_name) do |features, whens, thens, initial_values = nil|
+          given_proc.call(features, whens, thens, initial_values)
+        end
+      end
+      wrapper
+    end
+    
+    def when_wrapper
+      wrapper = Object.new
+      @when_overrides.each do |when_name, when_proc|
+        wrapper.define_singleton_method(when_name) do |*args|
+          when_proc.call(*args)
+        end
+      end
+      wrapper
+    end
+    
+    def then_wrapper
+      wrapper = Object.new
+      @then_overrides.each do |then_name, then_proc|
+        wrapper.define_singleton_method(then_name) do |*args|
+          then_proc.call(*args)
+        end
+      end
+      wrapper
+    end
+    
+    def initialize_classy_implementations(test_implementation)
+      # Create classy suites
+      test_implementation.suites.each do |key, suite_data|
+        @suites_overrides[key] = ->(description, givens_dict) do
+          {
+            'name' => description,
+            'givens' => givens_dict
+          }
+        end
+      end
+      
+      # Create classy givens
+      test_implementation.givens.each do |key, given_cb|
+        @given_overrides[key] = ->(features, whens, thens, initial_values = nil) do
+          BaseGiven.new(features, whens, thens, given_cb, initial_values, @test_adapter)
+        end
+      end
+      
+      # Create classy whens
+      test_implementation.whens.each do |key, when_cb_proc|
+        @when_overrides[key] = ->(*args) do
+          when_cb = when_cb_proc.call(*args)
+          BaseWhen.new(key, when_cb)
+        end
+      end
+      
+      # Create classy thens
+      test_implementation.thens.each do |key, then_cb_proc|
+        @then_overrides[key] = ->(*args) do
+          then_cb = then_cb_proc.call(*args)
+          BaseThen.new(key, then_cb)
+        end
+      end
+    end
+    
+    def initialize_test_jobs
+      @test_jobs = []
+      @specs.each_with_index do |suite_spec, i|
+        # Create a BaseSuite instance
+        suite = BaseSuite.new(suite_spec['name'], suite_spec['givens'])
+        suite.index = i
+        
+        # Create a test job
+        test_job = {
+          suite: suite,
+          receiveTestResourceConfig: ->(pm, test_resource_config) { run_test_job(suite, pm, test_resource_config) },
+          to_obj: -> { suite.to_obj }
+        }
+        
+        @test_jobs << test_job
+      end
+    end
+    
+    def run_test_job(suite, pm, test_resource_config)
+      t_log = ->(*args) { puts args.join(' ') }
+      
+      # Run the suite
+      suite_done = suite.run(
+        @test_subject,
+        test_resource_config,  # Use the actual test resource configuration
+        ->(f_path, value) { nil },  # Simple artifactory
+        t_log,
+        pm
+      )
+      
+      # Create result object
+      result = Object.new
+      result.instance_variable_set(:@fails, suite_done.fails)
+      result.instance_variable_set(:@artifacts, suite_done.artifacts)
+      result.instance_variable_set(:@features, suite_done.features)
+      
+      def result.fails; @fails; end
+      def result.artifacts; @artifacts; end
+      def result.features; @features; end
+      
+      result
+    rescue => e
+      puts "Error in test job: #{e.message}"
+      puts e.backtrace
+      
+      result = Object.new
+      result.instance_variable_set(:@fails, 1)
+      result.instance_variable_set(:@artifacts, [])
+      result.instance_variable_set(:@features, [])
+      
+      def result.fails; @fails; end
+      def result.artifacts; @artifacts; end
+      def result.features; @features; end
+      
+      result
+    end
+    
+    def receiveTestResourceConfig(partialTestResource, websocket_port = 'ipcfile')
+      # Parse the test resource configuration
+      test_resource_config = parse_test_resource_config(partialTestResource)
+      
+      pm = PM_Ruby.new(test_resource_config, websocket_port)
+      
+      # Run all test jobs
+      total_fails = 0
+      all_features = []
+      all_artifacts = []
+      suite_results = []
+      
+      @test_jobs.each do |job|
+        begin
+          # Update the job's receiveTestResourceConfig to pass test_resource_config
+          result = run_test_job(job[:suite], pm, test_resource_config)
+          total_fails += result.fails
+          all_features.concat(result.features)
+          all_artifacts.concat(result.artifacts)
+          suite_results << job[:to_obj].call
+        rescue => e
+          puts "Error running test job: #{e.message}"
+          total_fails += 1
+        end
+      end
+      
+      # Write tests.json
+      write_tests_json(suite_results, total_fails, all_features.uniq, all_artifacts)
+      
+      # Return result
+      IFinalResults.new(
+        failed: total_fails > 0,
+        fails: total_fails,
+        artifacts: all_artifacts,
+        features: all_features.uniq
+      )
+    end
+    
+    private
+    
+    def parse_test_resource_config(partialTestResource)
+      begin
+        config = JSON.parse(partialTestResource)
+        # Create a hash that can be used as test resource configuration
+        # The PM_Ruby expects certain methods to be available
+        config_hash = {
+          'name' => config['name'] || 'default',
+          'fs' => config['fs'] || '.',
+          'ports' => config['ports'] || [],
+          'timeout' => config['timeout'] || 30000,
+          'retries' => config['retries'] || 0,
+          'environment' => config['environment'] || {}
+        }
+        # Create an object that responds to the needed methods
+        test_resource = Object.new
+        test_resource.define_singleton_method(:name) { config_hash['name'] }
+        test_resource.define_singleton_method(:fs) { config_hash['fs'] }
+        test_resource.define_singleton_method(:ports) { config_hash['ports'] }
+        test_resource.define_singleton_method(:timeout) { config_hash['timeout'] }
+        test_resource.define_singleton_method(:retries) { config_hash['retries'] }
+        test_resource.define_singleton_method(:environment) { config_hash['environment'] }
+        test_resource
+      rescue JSON::ParserError
+        # If not valid JSON, create a default config
+        test_resource = Object.new
+        test_resource.define_singleton_method(:name) { 'default' }
+        test_resource.define_singleton_method(:fs) { '.' }
+        test_resource.define_singleton_method(:ports) { [] }
+        test_resource.define_singleton_method(:timeout) { 30000 }
+        test_resource.define_singleton_method(:retries) { 0 }
+        test_resource.define_singleton_method(:environment) { {} }
+        test_resource
+      end
+    end
+    
+    def write_tests_json(suite_results, total_fails, features, artifacts)
+      # Flatten all givens from all suites
+      all_givens = []
+      suite_results.each do |suite|
+        if suite[:givens]
+          all_givens.concat(suite[:givens])
+        end
+      end
+      
+      tests_data = {
+        'name' => @specs.first ? @specs.first['name'] : 'Unnamed Test',
+        'givens' => all_givens,
+        'fails' => total_fails,
+        'failed' => total_fails > 0,
+        'features' => features,
+        'artifacts' => artifacts
+      }
+      
+      # Create directory if it doesn't exist
+      dir_path = 'testeranto/reports/'
+      FileUtils.mkdir_p(dir_path) unless Dir.exist?(dir_path)
+      
+      # Write to file
+      tests_json_path = "#{dir_path}/ruby.Calculator.test.ts.json"
+      File.write(tests_json_path, JSON.pretty_generate(tests_data))
+      puts "tests.json written to: #{tests_json_path}"
+    end
+  end
+  
+  # Main function
+  def self.main
+    puts "Rubeno Ruby implementation"
+    
+    # Check command line arguments
+    if ARGV.length < 1
+      puts "No test arguments provided - exiting"
+      exit 0
+    end
+    
+    partialTestResource = ARGV[0]
+    websocket_port = ARGV[1] || 'ipcfile'
+    
+    # We need a default instance to run
+    # In a real implementation, this would be set elsewhere
+    if $default_rubeno_instance.nil?
+      puts "WARNING: No default Rubeno instance has been configured"
+      puts "Creating a minimal default instance for testing..."
+      
+      # Create a minimal test implementation
+      minimal_implementation = ITestImplementation.new(
+        suites: { 'Default' => { description: "Default test suite" } },
+        givens: { 
+          'Default' => ->(initial_values) do
+            # Return a simple object
+            Object.new
+          end
+        },
+        whens: {
+          'noop' => ->() do
+            ->(store) do
+              store
+            end
+          end
+        },
+        thens: {
+          'alwaysTrue' => ->() do
+            ->(store) do
+              true
+            end
+          end
+        }
+      )
+      
+      # Create a minimal test specification
+      minimal_specification = ->(suites, givens, whens, thens) do
+        # The wrappers are objects with methods, not hashes
+        # So we need to use them correctly
+        [
+          suites.Default('Minimal Test Suite', {
+            'test1' => givens.Default(
+              ['minimal test'],
+              [],
+              [thens.alwaysTrue()],
+              nil
+            )
+          })
+        ]
+      end
+      
+      # Create and set a default instance
+      $default_rubeno_instance = Rubeno.new(
+        nil,
+        minimal_specification,
+        minimal_implementation,
+        ITTestResourceRequest.new(ports: 0),
+        SimpleTestAdapter.new
+      )
+      
+      puts "Minimal default instance created"
+    end
+    
+    result = $default_rubeno_instance.receiveTestResourceConfig(partialTestResource, websocket_port)
+    exit result.fails
+  end
+  
+  # Store the default instance
+  $default_rubeno_instance = nil
+  
+  def self.set_default_instance(instance)
+    $default_rubeno_instance = instance
+  end
+  
+  # Helper function to create a Rubeno instance
+  def self.Rubeno(input_val = nil, test_specification = nil, test_implementation = nil, test_adapter = nil, test_resource_requirement = nil, uber_catcher = nil)
+    instance = Rubeno.new(
+      input_val,
+      test_specification,
+      test_implementation,
+      test_resource_requirement || ITTestResourceRequest.new,
+      test_adapter || SimpleTestAdapter.new,
+      uber_catcher
+    )
+    instance
+  end
+end

data/lib/simple_adapter.rb

@@ -0,0 +1,43 @@
+require 'types'
+
+module Rubeno
+  class SimpleTestAdapter
+    include ITestAdapter
+    
+    def before_all(input_val, tr, pm)
+      input_val
+    end
+    
+    def after_all(store, pm)
+      store
+    end
+    
+    def before_each(subject, initializer, test_resource, initial_values, pm)
+      subject
+    end
+    
+    def after_each(store, key, pm)
+      store
+    end
+    
+    def and_when(store, when_cb, test_resource, pm)
+      if when_cb.respond_to?(:call)
+        when_cb.call(store)
+      else
+        store
+      end
+    end
+    
+    def but_then(store, then_cb, test_resource, pm)
+      if then_cb.respond_to?(:call)
+        then_cb.call(store)
+      else
+        store
+      end
+    end
+    
+    def assert_this(t)
+      !!t
+    end
+  end
+end

data/lib/types.rb

@@ -0,0 +1,85 @@
+module Rubeno
+  # Type definitions for Rubeno
+  
+  # Test resource configuration
+  class ITTestResourceConfiguration
+    attr_accessor :name, :fs, :ports, :browser_ws_endpoint, :timeout, :retries, :environment
+    
+    def initialize(name:, fs:, ports:, browser_ws_endpoint: nil, timeout: nil, retries: nil, environment: {})
+      @name = name
+      @fs = fs
+      @ports = ports
+      @browser_ws_endpoint = browser_ws_endpoint
+      @timeout = timeout
+      @retries = retries
+      @environment = environment
+    end
+  end
+  
+  # Test adapter interface
+  module ITestAdapter
+    def before_all(input_val, tr, pm)
+      input_val
+    end
+    
+    def after_all(store, pm)
+      store
+    end
+    
+    def before_each(subject, initializer, test_resource, initial_values, pm)
+      subject
+    end
+    
+    def after_each(store, key, pm)
+      store
+    end
+    
+    def and_when(store, when_cb, test_resource, pm)
+      store
+    end
+    
+    def but_then(store, then_cb, test_resource, pm)
+      store
+    end
+    
+    def assert_this(t)
+      !!t
+    end
+  end
+  
+  # Test specification function type
+  ITestSpecification = Proc
+  
+  # Test implementation structure
+  class ITestImplementation
+    attr_accessor :suites, :givens, :whens, :thens
+    
+    def initialize(suites:, givens:, whens:, thens:)
+      @suites = suites
+      @givens = givens
+      @whens = whens
+      @thens = thens
+    end
+  end
+  
+  # Test resource request
+  class ITTestResourceRequest
+    attr_accessor :ports
+    
+    def initialize(ports: 0)
+      @ports = ports
+    end
+  end
+  
+  # Final results
+  class IFinalResults
+    attr_accessor :failed, :fails, :artifacts, :features
+    
+    def initialize(failed:, fails:, artifacts:, features:)
+      @failed = failed
+      @fails = fails
+      @artifacts = artifacts
+      @features = features
+    end
+  end
+end

data/rubeno.rb

@@ -0,0 +1,3 @@
+# This is the main entry point for the Rubeno gem
+# It loads the actual implementation
+require 'rubeno'

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: testeranto.rubeno
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Adam Wong
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2010-04-03 00:00:00.000000000 Z
+dependencies: []
+description: The Ruby implementation of Testeranto
+email: adamwong246@gmail.com
+executables:
+- rubeno
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/rubeno
+- lib/base_given.rb
+- lib/base_suite.rb
+- lib/base_then.rb
+- lib/base_when.rb
+- lib/pm/ruby.rb
+- lib/rubeno.rb
+- lib/simple_adapter.rb
+- lib/types.rb
+- rubeno.rb
+homepage: http://rubygems.org/gems/rubeno
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 3
+summary: The Ruby implementation of Testeranto
+test_files: []