wabur 0.2.0d1 → 0.4.0d1

data/test/test_expr_not.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprNot < TestImpl
+
+  def test_not_native
+    x = WAB::Impl::Not.new(WAB::Impl::Eq.new('num', 7))
+    assert_equal(['NOT', ['EQ', 'num', 7]], x.native, 'NOT native mismatch')
+  end
+
+  def test_not
+    d = make_sample_data
+    x = WAB::Impl::Not.new(WAB::Impl::Eq.new('num', 8))
+    assert(x.eval(d), 'checking NOT match')
+
+    x = WAB::Impl::Not.new(WAB::Impl::Eq.new('num', 7))
+    refute(x.eval(d), 'checking NOT mismatch')
+  end
+
+end # TestExprNot

data/test/test_expr_or.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprOr < TestImpl
+
+  def test_or_native
+    x = WAB::Impl::Or.new(WAB::Impl::Has.new('num'), WAB::Impl::Eq.new('num', 7))
+    assert_equal(['OR', ['HAS', 'num'], ['EQ', 'num', 7]], x.native, 'OR native mismatch')
+  end
+
+  def test_or
+    d = make_sample_data
+    x = WAB::Impl::Or.new(WAB::Impl::Has.new('str'), WAB::Impl::Eq.new('num', 8))
+    assert(x.eval(d), 'checking OR match')
+
+    x = WAB::Impl::Or.new(WAB::Impl::Has.new('none'), WAB::Impl::Eq.new('num', 8))
+    refute(x.eval(d), 'checking OR mismatch')
+  end
+
+  # TBD tests with no args, with one, with more than 2, test using append_arg
+
+end # TestExprOr

data/test/test_expr_regex.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+require 'wab'
+require 'wab/impl'
+
+class TestExprRegex < TestImpl
+
+  def test_regex_native
+    x = WAB::Impl::Regex.new('str', '^a *.')
+    assert_equal(['REGEX', 'str', '^a *.'], x.native, 'REGEX native mismatch')
+  end
+
+  def test_regex_int
+    d = make_sample_data
+    x = WAB::Impl::Regex.new('str', '^a .*')
+    assert(x.eval(d), 'checking REGEX match with string arg')
+
+    x = WAB::Impl::Regex.new('str', '^x .*')
+    refute(x.eval(d), 'checking REGEX mismatch with string arg')
+
+    x = WAB::Impl::Regex.new('num', 8)
+    refute(x.eval(d), 'checking REGEX mismatch with an integer arg')
+  end
+
+  # TBD more tests for each type, Float, boolean, String, URI, UUID, Time, BigDecimal, nil
+
+end # TestExprRegex

data/test/test_impl.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+require 'wab/impl'
+
+class TestImpl < Minitest::Test
+
+  def setup
+    @shell = WAB::Impl::Shell.new(
+      WAB::Impl::Configuration.new('',
+        'base' => File.join(__dir__, 'tmp')
+      )
+    )
+  end
+
+  def make_sample_data()
+    @shell.data({
+                  boo: true,
+                  n: nil,
+                  num: 7,
+                  float: 7.654,
+                  str: 'a string',
+                  t: Time.gm(2017, 1, 5, 15, 4, 33.123456789),
+                  big: BigDecimal('63.21'),
+                  uri: URI('http://opo.technology/sample'),
+                  uuid: WAB::UUID.new('b0ca922d-372e-41f4-8fea-47d880188ba3'),
+                  a: [],
+                  h: {},
+                })
+  end
+end # TestImpl
+
+require 'test_configuration'
+require 'test_data'
+require 'test_expr'
+require 'test_model'

data/test/test_io_shell.rb

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+require 'wab/impl'
+require 'wab/io'
+require 'mirror_controller'
+
+class TestIoShell < Minitest::Test
+
+  def test_default_controller
+    run_fork_test([
+                   [{rid: 'rid-mirror', api: 1, body: {kind: 'sample', num: 7}},
+                    {rid: 'rid-mirror', api: 2, body: {kind: 'sample', num: 7}}]
+                  ])
+  end
+
+  def test_create
+    run_fork_test([
+                   [{rid: 'rid-create', api: 1, body: {op: 'NEW', path: ['sample'], content: {kind: 'sample', num: 7}}},
+                    {rid: '1', api: 3, body: { insert:{ kind: 'sample', num: 7}}}],
+                   [{rid: '1', api: 4, body: {ref: 123, code: 0}},
+                    {rid: 'rid-create', api: 2, body: { ref: 123, code: 0}}]
+                  ])
+  end
+
+  def test_create_with_where
+    run_fork_test([
+                   [{rid: 'rid-create-where', api: 1, body: {op: 'NEW', path: ['sample'], query: {id: 12345}, content: {kind: 'sample', id: 12345, num: 7}}},
+                    {rid: '1', api: 3, body: {where: ['AND', ['EQ', 'kind', "'sample"],['EQ', 'id', 12345]], insert:{ kind: 'sample', id: 12345, num: 7}}}],
+                   [{rid: '1', api: 4, body: {ref: 123, code: 0}},
+                    {rid: 'rid-create-where', api: 2, body: { ref: 123, code: 0 }}]
+                  ])
+  end
+
+  def test_create_error
+    run_fork_test([
+                   [{rid: 'rid-create-error', api: 1, body: {op: 'NEW', path: ['sample'], content: {kind: 'sample', num: 7}}},
+                    {rid: '1', api: 3, body: { insert:{ kind: 'sample', num: 7}}}],
+                   [{rid: '1', api: 4, body: {ref: 123, code: -1, error: 'something went wrong'}},
+                    {rid: 'rid-create-error', api: 2, body: { code: -1, error: 'WAB::Error: error on sample create. something went wrong'}}]
+                  ])
+  end
+
+  def test_read_by_id
+    run_fork_test([
+                   [{rid: 'rid-read-id', api: 1, body: {op: 'GET', path: ['sample', '12345']}},
+                    {rid: '1', api: 3, body: {where: 12345, select: '$'}}],
+                   [{rid: '1', api: 4, body: {code: 0, results:[{kind: 'sample', id: 12345, num: 7}]}},
+                    {rid: 'rid-read-id', api: 2, body: { code: 0, results:[{ id: 12345, data: { kind: 'sample', id: 12345, num: 7}}]}}]
+                  ])
+  end
+
+  def test_read_by_attrs
+    run_fork_test([
+                   [{rid: 'rid-read-attrs', api: 1, body: {op: 'GET', path: ['sample'], query: {id: 12345}}},
+                    {rid: '1', api: 3, body: {where: ['AND', ['EQ', 'kind', "'sample"], ['EQ', 'id', 12345]], select: {id: '$ref', data: '$' }}}],
+                   [{rid: '1', api: 4, body: {code: 0, results: [{id: 12345, data: {kind: 'sample', id: 12345, num: 7}}]}},
+                    {rid: 'rid-read-attrs', api: 2, body: {code: 0, results:[{id: 12345, data: {kind: 'sample', id: 12345, num: 7}}]}}]
+                  ])
+  end
+
+  def test_read_list
+    run_fork_test([
+                   [{rid: 'rid-read-list', api: 1, body: {op: 'GET', path: ['sample']}},
+                    {rid: '1', api: 3, body: {where: ['EQ', 'kind', "'sample"], select: { id: '$ref', data: '$'}}}],
+                   [{rid: '1', api: 4, body: {code: 0, results: [12345]}},
+                    {rid: 'rid-read-list', api: 2, body: {code: 0, results:[12345]}}]
+                  ])
+  end
+
+  def test_read_select
+    run_fork_test([
+                   [{rid: 'rid-read-select', api: 1, body: {op: 'GET', path: ['sample', 'list'], query: { Age: 'num' }}},
+                    {rid: '1', api: 3, body: {where: ['EQ', 'kind', "'sample"], select: { ref: '$ref', Age: 'num'}}}],
+                   [{rid: '1', api: 4, body: {code: 0, results: [{ref: 12345, Age: 7 }]}},
+                    {rid: 'rid-read-select', api: 2, body: {code: 0, results:[{ref: 12345, Age: 7 }]}}]
+                  ])
+  end
+
+  def test_update_by_id
+    run_fork_test([
+                   [{rid: 'rid-update-id', api: 1, body: {op: 'MOD', path: ['sample', '12345'], content: {kind: 'sample', id: 12345, num: 7}}},
+                    {rid: '1', api: 3, body: {where: 12345, update: { kind: 'sample', id: 12345, num: 7}}}],
+                   [{rid: '1', api: 4, body: {code: 0, updated: [12345]}},
+                    {rid: 'rid-update-id', api: 2, body: { code: 0, updated: [12345]}}]
+                  ])
+  end
+
+  def test_update_by_attrs
+    run_fork_test([
+                   [{rid: 'rid-update-attrs', api: 1, body: {op: 'MOD', path: ['sample'], query: {id: 12345}, content: {kind: 'sample', id: 12345, num: 7}}},
+                    {rid: '1', api: 3, body: {where: ['AND', ['EQ', 'kind', "'sample"],['EQ', 'id', 12345]], update: { kind: 'sample', id: 12345, num: 7}}}],
+                   [{rid: '1', api: 4, body: {code: 0, updated: [12345]}},
+                    {rid: 'rid-update-attrs', api: 2, body: { code: 0, updated: [12345]}}]
+                  ])
+  end
+
+  def test_delete_by_id
+    run_fork_test([
+                   [{rid: 'rid-delete-id', api: 1, body: {op: 'DEL', path: ['sample', '12345']}},
+                    {rid: '1', api: 3, body: {where: 12345, delete: nil}}],
+                   [{rid: '1', api: 4, body: {code: 0, deleted: [12345]}},
+                    {rid: 'rid-delete-id', api: 2, body: { code: 0, deleted: [12345]}}]
+                  ])
+  end
+
+  def test_delete_by_attrs
+    run_fork_test([
+                   [{rid: 'rid-delete-attrs', api: 1, body: {op: 'DEL', path: ['sample'], query: {id: 12345}}},
+                    {rid: '1', api: 3, body: {where: ['AND', ['EQ', 'kind', "'sample"],['EQ', 'id', 12345]], delete: nil}}],
+                   [{rid: '1', api: 4, body: {code: 0, deleted: [12345]}},
+                    {rid: 'rid-delete-attrs', api: 2, body: { code: 0, deleted: [12345]}}]
+                  ])
+  end
+
+  def test_timeout
+    run_fork_test([
+                   [{rid: 'rid-timeout', api: 1, body: {op: 'NEW', path: ['sample'], content: {kind: 'sample', num: 7}}},
+                    {rid: '1', api: 3, body: { insert:{ kind: 'sample', num: 7}}}],
+                   [nil,
+                    {rid: 'rid-timeout', api: 2, body: { code: -1, error: 'WAB::Error: error on sample create. Timed out waiting for 1.'}}]
+                  ])
+  end
+
+  # Fork and create a shell in the child. For each pair in the script send the
+  # first message and wait for the second. Compare second for test success of
+  # failure.
+  def run_fork_test(script)
+    # Windows does not support fork
+    return if RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
+
+    to_r, to_w = IO.pipe
+    from_r, from_w = IO.pipe
+
+    if fork.nil? # child
+      $stdin = to_r
+      to_w.close
+      $stdout = from_w
+      from_r.close
+
+      shell = WAB::IO::Shell.new(2, 'kind', 0)
+      shell.timeout = 0.5
+      shell.logger.level = Logger::WARN # change to Logger::INFO for debugging
+      shell.register_controller(nil, MirrorController.new(shell))
+      shell.start
+
+      Process.exit(0)
+    else
+      to_r.close
+      from_w.close
+
+      # Shell#data should be called instead but for this test a shell is not
+      # desired.
+      script.each { |pair|
+        unless pair[0].nil?
+          to_w.puts(WAB::Impl::Data.new(pair[0], false).json)
+          to_w.flush
+        end
+
+        reply = nil
+        Oj.strict_load(from_r, symbol_keys: true) { |msg| reply = msg; break }
+
+        # remove backtrace if an error
+        bt = nil
+        if !reply.nil? && !reply[:body].nil?
+          bt = reply[:body].delete(:backtrace)
+        end
+        begin
+          assert_equal(pair[1], reply)
+        rescue Exception => e
+          puts ''
+          puts bt
+          raise e
+        end
+      }
+      # On error the pipe may be closed from the child side so the write will
+      # fail. Thats okay as the write is only to tell the child to shutdown
+      # and it already has.
+      begin
+        to_w.puts(WAB::Impl::Data.new({ api: -2 }, false).json)
+        to_w.flush
+      rescue Exception
+      end
+    end
+  end
+
+end

data/test/test_model.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+require 'wab/impl/model'
+
+class TestModel < TestImpl
+
+  def test_model_create
+    # nil arg indicates don't save to disk
+    model = WAB::Impl::Model.new(nil)
+    tql = {
+      rid: 12345,
+      insert: {
+        kind: 'Person',
+        name: 'Peter',
+        age: 63
+      }
+    }
+    result = model.query(tql)
+    assert_equal(0, result[:code], 'expected a 0 result code')
+    assert_equal(12345, result[:rid], 'expected correct rid')
+    ref = result[:ref]
+    # get and verify object was stored.
+    obj = model.get(ref)
+
+    assert_equal({kind: 'Person', name: 'Peter', age: 63}, obj.native, 'obj get mismatch')
+  end
+
+end # TestModel

data/test/test_runner.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+require 'net/http'
+require 'oj'
+
+require 'wab/impl'
+require 'wab/io'
+
+# -----------------------------------------------------------------------------
+# This is to verify that WAB-Runners behave as expected.
+#
+# Requirements:
+#   - The Runner (e.g. OpO daemon) should be started with the MirrorController
+#     class.
+#   - The host and port must be the last argument on the command line when
+#     invoking the test.
+#
+# Example usage:
+#    runner_test.rb localhost:6363
+# -----------------------------------------------------------------------------
+
+raise ArgumentError, 'Host and port not supplied.' if ARGV.empty?
+
+$host, $port = ARGV[-1].split(':')
+$port = $port.to_i
+
+class TestRunner < Minitest::Test
+
+  # The Runner or rather it's storage is stateful so all steps in the test
+  # must be made in order to keep the test self contained. Each step is a
+  # separate function though.
+  def test_runner_basics
+    http = Net::HTTP.new($host, $port)
+
+    # Delete all records to start with a clean database
+    clear_records(http)
+    ref = create_record(http)
+    read_record(http, ref)
+    list_records(http, ref)
+
+    ref = update_record(http, ref)
+    read_after_update(http, ref)
+
+    delete_record(http, ref)
+    read_after_delete(http, ref)
+  end
+
+  def clear_records(http)
+    resp = http.send_request('DELETE', '/v1/Article')
+    # Response should be an OK with a JSON body.
+    assert_equal(Net::HTTPOK, resp.class, 'response not an OK')
+    reply = Oj.strict_load(resp.body, symbol_keys: true)
+  end
+
+  # Returns the reference of the created record.
+  def create_record(http)
+    json = %|{
+    "kind": "Article",
+    "title": "Sample",
+    "text": "Just some random text."
+}|
+    resp = http.send_request('PUT', '/v1/Article', json, { 'Content-Type' => 'application/json' })
+    # Response should be an OK with a JSON body.
+    assert_equal(Net::HTTPOK, resp.class, 'response not an OK')
+    reply = Oj.strict_load(resp.body, symbol_keys: true)
+
+    # Make sure the message has the correct fields and values.
+    assert_equal(0, reply[:code], 'create reply.code should be 0 meaning no error')
+    ref = reply[:ref]
+    refute_equal(nil, ref, 'create reply record reference can not be nil')
+    refute_equal(0, ref, 'create reply record reference can not be 0')
+    ref
+  end
+
+  def read_record(http, ref)
+    resp = http.send_request('GET', "/v1/Article/#{ref}")
+    assert_equal(Net::HTTPOK, resp.class, 'response not an OK')
+    reply = Oj.strict_load(resp.body, symbol_keys: true)
+
+    # Make sure the message has the correct fields and values.
+    assert_equal(0, reply[:code], 'read reply.code should be 0 meaning no error')
+    results = reply[:results]
+    assert_equal(1, results.length, 'read reply.results should contain exactly one member')
+    record = results[0]
+    assert_equal(ref, record[:id], 'read reply.results[0].id should match the record reference')
+    obj = record[:data]
+    assert_equal('Article', obj[:kind], 'read reply obj.kind incorrect')
+    assert_equal('Sample', obj[:title], 'read reply obj.title incorrect')
+  end
+
+  def list_records(http, ref)
+    resp = http.send_request('GET', '/v1/Article')
+    assert_equal(Net::HTTPOK, resp.class, 'response not an OK')
+    reply = Oj.strict_load(resp.body, symbol_keys: true)
+
+    # Make sure the message has the correct fields and values.
+    assert_equal(0, reply[:code], 'read reply.code should be 0 meaning no error')
+    results = reply[:results]
+    assert_equal(1, results.length, 'read reply.results should contain exactly one member')
+    record = results[0]
+    assert_equal(ref, record[:id], 'read reply.results[0].id should match the record reference')
+    obj = record[:data]
+    assert_equal('Article', obj[:kind], 'read reply obj.kind incorrect')
+    assert_equal('Sample', obj[:title], 'read reply obj.title incorrect')
+  end
+
+  # Returns the reference of the updated record. There is no requirement that
+  # the reference will not change.
+  def update_record(http, ref)
+    json = %|{
+    "kind": "Article",
+    "title": "Sample",
+    "text": "Updated text."
+}|
+    resp = http.send_request('POST', "/v1/Article/#{ref}", json, { 'Content-Type' => 'application/json' })
+    # Response should be an OK with a JSON body.
+    assert_equal(Net::HTTPOK, resp.class, 'response not an OK')
+    reply = Oj.strict_load(resp.body, symbol_keys: true)
+
+    # Make sure the message has the correct fields and values.
+    assert_equal(0, reply[:code], 'update reply.code should be 0 meaning no error')
+    updated = reply[:updated]
+    assert_equal(1, updated.length, 'update reply.updated should contain exactly one member')
+    ref = updated[0]
+    refute_equal(nil, ref, 'update reply record reference can not be nil')
+    refute_equal(0, ref, 'update reply record reference can not be 0')
+    ref
+  end
+
+  def read_after_update(http, ref)
+    resp = http.send_request('GET', "/v1/Article/#{ref}")
+    assert_equal(Net::HTTPOK, resp.class, 'response not an OK')
+    reply = Oj.strict_load(resp.body, symbol_keys: true)
+
+    assert_equal(0, reply[:code], 'read after update reply.code should be 0 meaning no error')
+    results = reply[:results]
+    assert_equal(1, results.length, 'read after update reply.results should contain exactly one member')
+    record = results[0]
+    assert_equal(ref, record[:id], 'read after update reply.results[0].id should match the record reference')
+    obj = record[:data]
+    assert_equal('Updated text.', obj[:text], 'read after update reply obj.text incorrect')
+  end
+
+  def delete_record(http, ref)
+    resp = http.send_request('DELETE', "/v1/Article/#{ref}")
+    # Response should be an OK with a JSON body.
+    assert_equal(Net::HTTPOK, resp.class, 'response not an OK')
+    reply = Oj.strict_load(resp.body, symbol_keys: true)
+
+    # Make sure the message has the correct fields and values.
+    assert_equal(0, reply[:code], 'delete reply.code should be 0 meaning no error')
+    deleted = reply[:deleted]
+    assert_equal(1, deleted.length, 'delete reply.deleted should contain exactly one member')
+    ref = deleted[0]
+    refute_equal(nil, ref, 'delete reply record reference can not be nil')
+    refute_equal(0, ref, 'delete reply record reference can not be 0')
+  end
+
+  def read_after_delete(http, ref)
+    resp = http.send_request('GET', "/v1/Article/#{ref}")
+    assert_equal(Net::HTTPOK, resp.class, 'response not an OK')
+    reply = Oj.strict_load(resp.body, symbol_keys: true)
+
+    assert_equal(0, reply[:code], 'read after delete reply.code should be 0 meaning no error')
+    results = reply[:results]
+    assert_equal(0, results.length, 'read after delete reply.results should contain no members')
+  end
+
+  # TBD test failure modes as well
+  # TBD test multiple matches on update and delete
+  # TBD test no matches on update and delete
+  # TBD test queries
+
+end # TestRunner

data/test/tests.rb

@@ -1,12 +1,7 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-$: << File.dirname(__FILE__)
-$: << File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'lib')
+require_relative 'helper'
 
-require 'minitest'
-require 'minitest/autorun'
-
-require 'impl_test'
-
-require 'ioshell_test'
+require 'test_impl'
+require 'test_io_shell'