rubeno 0.0.5 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8dedd5e87189068d03353586100b545cb3431a82964a3706c6c7682fff5d340
-  data.tar.gz: 736b7c4dac0518bbfdbe9f19bbbecaf5dcfad19be11ee2a2a680cf7f2c02f19e
+  metadata.gz: 8a63050574ae2c21e6480e4b748056c9d2e165db6a5ee6f435e1198ca9daf308
+  data.tar.gz: e94ca7f92fd6371e4e89391b9a3820681f159a8419964e0bc25f9e0b455b3d43
 SHA512:
-  metadata.gz: 8bd1796520d9f8ceb13778f48d97de8e9ce1d69b74a4ef19fb505a36bd1345b2cf4413e627abd38a65fc64699a2eea3d36c473227248eb79bb46628b086e5f1a
-  data.tar.gz: fb8657b555b4f02931c9e760a4789b929040f026f077ead673cb9842bfee88747bda1a2336665d4c7119031a0a109a8c83a0010553b61aa15d83f7ff1f0e07b1
+  metadata.gz: f5920fe5b2a1a49f11bb26c9fc9912177555c5512a1a057904c64890458611c2b060a9685e4210731cfefa05eba2ea2c912739ea44541021828e926c10797c2b
+  data.tar.gz: 2ab9001839c14408446673f154f90af6074b70aa3adc6abd668a74669912151de96629a2a80393a4f19d74700611940fa04007c2038fcc8a542a3a4d075b549c

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/allTests/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/bin/rubeno

@@ -2,4 +2,4 @@
 
 require 'rubeno'
 
-puts "hello rubeno"
+Rubeno.main

data/lib/base_given.rb

@@ -0,0 +1,130 @@
+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)
+      @features = features
+      @whens = whens
+      @thens = thens
+      @given_cb = given_cb
+      @initial_values = initial_values
+      @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)
+      raise NotImplementedError, "given_that must be implemented by subclasses"
+    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,43 @@
+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)
+      raise NotImplementedError, "but_then must be implemented by subclasses"
+    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,46 @@
+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)
+      raise NotImplementedError, "and_when must be implemented by subclasses"
+    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/simple_adapter.rb

@@ -0,0 +1,43 @@
+require_relative '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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubeno
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.8
 platform: ruby
 authors:
 - Adam Wong
@@ -17,9 +17,17 @@ executables:
 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
 homepage: http://rubygems.org/gems/rubeno
 licenses: []
 metadata: {}