gloo 6.2.1 → 6.3.0

data/test.gloo/lang/load_lib_directive.test.gloo

@@ -0,0 +1,33 @@
+#
+# Top-of-file 'load lib' directive test
+#
+# The line below runs before this file's object tree is built, so a
+# core-library type is available to declarations in the same file.
+#
+load lib yaml
+
+tests [can] :
+  lang [can] :
+    load_lib_directive [can] :
+
+      # this declaration only parses because 'load lib yaml' above
+      # registered the type before the loader got here
+      cfg [yaml] :
+
+      library_type_is_available [test] :
+        description [string] : a load lib directive at the top of the file registers the library's types.
+        on_test [script] :
+          exists? object yaml
+          assert "expected the yaml type to be registered by the directive"
+
+          exists? object yml
+          assert "expected the yaml short name to be registered too"
+
+      typed_object_was_created [test] :
+        description [string] : an object of the library's type declared in the same file exists.
+        on_test [script] :
+          exists? instance tests.lang.load_lib_directive.cfg
+          assert "expected the [yaml] object to have been created during load"
+
+          check tests.lang.load_lib_directive.cfg for responds_to? ( 'load' )
+          assert "expected it to be a real yaml object that responds to load"

data/test.gloo/lang/naming.test.gloo

@@ -0,0 +1,44 @@
+#
+# Object naming tests
+#
+
+tests [can] :
+  lang [can] :
+    naming [can] :
+
+      dup [string] : first
+      dup [string] : second
+
+      Alpha [string] : mixed case
+
+      1 [string] : numeric name
+
+      string [string] : a type keyword as a name
+      put [string] : a verb keyword as a name
+
+      first_of_a_duplicate_name_wins [test] :
+        description [string] : when two siblings share a name, the path always reaches the first.
+        on_test [script] :
+          eval ^^.dup = 'first'
+          assert "expected the first 'dup' to be the one reached"
+
+      path_lookup_is_case_insensitive [test] :
+        description [string] : a pathname segment matches a name regardless of case.
+        on_test [script] :
+          eval tests.lang.naming.alpha = 'mixed case'
+          assert "expected lower-case lookup to find 'Alpha'"
+
+          eval tests.lang.naming.ALPHA = 'mixed case'
+          assert "expected upper-case lookup to find 'Alpha'"
+
+      numeric_and_keyword_names [test] :
+        description [string] : digits and reserved-looking words are valid object names.
+        on_test [script] :
+          eval tests.lang.naming.1 = 'numeric name'
+          assert "expected a numeric name to work"
+
+          eval ^^.string = 'a type keyword as a name'
+          assert "expected a type keyword to be usable as a name"
+
+          eval ^^.put = 'a verb keyword as a name'
+          assert "expected a verb keyword to be usable as a name"

data/test.gloo/objs/cipher.test.gloo

@@ -0,0 +1,45 @@
+#
+# Cipher object tests
+#
+
+tests [can] :
+  objs [can] :
+    cipher [can] :
+
+      plaintext [string] : attack at dawn
+
+      round_trip [test] :
+        description [string] : encrypt then decrypt returns the original text.
+        on_test [script] :
+          create tests.objs.cipher.c as cipher
+
+          tell tests.objs.cipher.c to generate_keys
+          check tests.objs.cipher.c.key for blank?
+          refute "expected generate_keys to set a key"
+
+          put ^^.plaintext into tests.objs.cipher.c.data
+          tell tests.objs.cipher.c to encrypt
+          eval tests.objs.cipher.c.data = ^^.plaintext
+          refute "expected the data to be encrypted (not the plaintext)"
+
+          tell tests.objs.cipher.c to decrypt
+          eval tests.objs.cipher.c.data = ^^.plaintext
+          assert "expected decrypt to restore the original text"
+
+      shared_keys [test] :
+        description [string] : a second cipher with the same key + init_vector can decrypt.
+        on_test [script] :
+          create tests.objs.cipher.a as cipher
+          create tests.objs.cipher.b as cipher
+
+          tell tests.objs.cipher.a to generate_keys
+          put ^^.plaintext into tests.objs.cipher.a.data
+          tell tests.objs.cipher.a to encrypt
+
+          put tests.objs.cipher.a.key into tests.objs.cipher.b.key
+          put tests.objs.cipher.a.init_vector into tests.objs.cipher.b.init_vector
+          put tests.objs.cipher.a.data into tests.objs.cipher.b.data
+
+          tell tests.objs.cipher.b to decrypt
+          eval tests.objs.cipher.b.data = ^^.plaintext
+          assert "expected the second cipher to decrypt with the shared key"

data/test.gloo/objs/erb.test.gloo

@@ -20,6 +20,12 @@ tests [can] :
           name [string] : gloo
         result [text] :
 
+      with_logic [erb] :
+        template [text] : <%= n == "yes" ? "ACTIVE" : "closed" %>
+        params [can] :
+          n [string] : no
+        result [text] :
+
       run_basic [test] :
         description [string] : Render a template with a param
         on_test [script] :
@@ -33,3 +39,15 @@ tests [can] :
           tell ^^.aliased_template to run
           eval ^^.aliased_template.result = 'gloo!!'
           assert "expected alias to be resolved before rendering the template"
+
+      run_with_logic [test] :
+        description [string] : A <% %> tag runs Ruby; the param drives which branch renders
+        on_test [script] :
+          tell ^^.with_logic to run
+          eval ^^.with_logic.result = 'closed'
+          assert "expected the 'no' param to render the closed branch"
+
+          put 'yes' into ^^.with_logic.params.n
+          tell ^^.with_logic to run
+          eval ^^.with_logic.result = 'ACTIVE'
+          assert "expected the 'yes' param to render the ACTIVE branch"

data/test.gloo/objs/file.test.gloo

@@ -0,0 +1,77 @@
+#
+# File object tests
+#
+# The file object's value is a path.  These tests write a scratch
+# file under /tmp, exercise it, and delete it at the end.
+#
+
+tests [can] :
+  objs [can] :
+    file [can] :
+
+      f [file] : /tmp/gloo_file_test.txt
+      names [file] : /Users/me/project/report.csv
+
+      first [string] : first line
+      second [string] : second line
+      back [string] :
+
+      write_read_round_trip [test] :
+        description [string] : write puts an object's value in the file; read gets it back.
+        on_test [script] :
+          tell ^^.f to write ( ^^.first )
+
+          check ^^.f for exists?
+          assert "expected the file to exist after write"
+
+          check ^^.f for is_file?
+          assert "expected exists to be a regular file"
+
+          check ^^.f for is_dir?
+          refute "expected the file not to be a directory"
+
+          tell ^^.f to read ( ^^.back )
+          eval ^^.back = 'first line'
+          assert "expected read to return what was written"
+
+          tell ^^.f to delete
+
+      append_adds_a_line [test] :
+        description [string] : append adds a new line to the file.
+        on_test [script] :
+          tell ^^.f to write ( ^^.first )
+          tell ^^.f to append ( ^^.second )
+
+          tell ^^.f to read ( ^^.back )
+          check ^^.back for substring? ( "first line" )
+          assert "expected the original line to still be there"
+          check ^^.back for substring? ( "second line" )
+          assert "expected the appended line to be there"
+
+          tell ^^.f to delete
+
+      path_parts [test] :
+        description [string] : get_name, get_ext and get_parent read the path, not the disk.
+        on_test [script] :
+          tell ^^.names to get_name
+          eval it = 'report'
+          assert "expected the base name without extension"
+
+          tell ^^.names to get_ext
+          eval it = '.csv'
+          assert "expected the extension"
+
+          tell ^^.names to get_parent
+          eval it = '/Users/me/project'
+          assert "expected the parent directory"
+
+      delete_removes_the_file [test] :
+        description [string] : delete removes the file from disk.
+        on_test [script] :
+          tell ^^.f to write ( ^^.first )
+          check ^^.f for exists?
+          assert "sanity: file exists before delete"
+
+          tell ^^.f to delete
+          check ^^.f for exists?
+          refute "expected the file to be gone after delete"

data/test.gloo/objs/function.test.gloo

@@ -0,0 +1,54 @@
+#
+# Function object tests
+#
+# The 'invoke' verb and inline invoke( ... ) are covered in
+# verbs/invoke.test.gloo.  These tests cover the function object
+# itself: the 'invoke' message, param defaults, and the
+# after_invoke event.
+#
+
+tests [can] :
+  objs [can] :
+    function [can] :
+
+      after_ran [bool] : false
+
+      greet [ƒ] :
+        params [can] :
+          name [string] : Default Person
+        on_invoke [script] :
+          put 'Hi, ' + ^.params.name into ^.result
+        after_invoke [script] :
+          put true into tests.objs.function.after_ran
+        result [string] :
+
+      boom [ƒ] :
+        params [can] :
+        on_invoke [script] :
+          put no_such_object into ^.result
+        after_invoke [script] :
+          put true into tests.objs.function.after_ran
+        result [string] :
+
+      invoke_message_uses_param_defaults [test] :
+        description [string] : the invoke message with no args runs on_invoke against the param defaults.
+        on_test [script] :
+          tell ^^.greet to invoke
+          eval ^^.greet.result = 'Hi, Default Person'
+          assert "expected on_invoke to run with the default param value"
+
+      after_invoke_runs_on_success [test] :
+        description [string] : after_invoke runs once the function has been invoked.
+        on_test [script] :
+          put false into ^^.after_ran
+          tell ^^.greet to invoke
+          eval ^^.after_ran = true
+          assert "expected after_invoke to run after a successful invoke"
+
+      after_invoke_runs_on_failure [test] :
+        description [string] : after_invoke still runs when on_invoke hits an error.
+        on_test [script] :
+          put false into ^^.after_ran
+          tell ^^.boom to invoke
+          eval ^^.after_ran = true
+          assert "expected after_invoke to run even after on_invoke failed"

data/test.gloo/objs/json.test.gloo

@@ -0,0 +1,70 @@
+#
+# JSON object tests
+#
+
+tests [can] :
+  objs [can] :
+    json [can] :
+
+      payload [json] : BEGIN
+        { "title":"Brute Force",
+          "meta":{ "author":"ESR", "year":"2003" } }
+        END
+
+      compact [json] : {"a":"1","b":{"c":"2"}}
+
+      source [can] :
+        name [string] : gloo
+        kind [string] : language
+
+      built [json] :
+      out [can] :
+      found [string] :
+
+      get_a_value [test] :
+        description [string] : get pulls a value out by dotted path.
+        on_test [script] :
+          tell ^^.payload to get ( 'title' )
+          eval it = 'Brute Force'
+          assert "expected the top-level title"
+
+          tell ^^.payload to get ( 'meta.author' )
+          eval it = 'ESR'
+          assert "expected the nested author"
+
+      get_missing_is_blank [test] :
+        description [string] : get for a path that isn't there returns blank.
+        on_test [script] :
+          tell ^^.payload to get ( 'nope' )
+          put it into tests.objs.json.found
+          check tests.objs.json.found for blank?
+          assert "expected a missing path to return blank"
+
+      parse_into_objects [test] :
+        description [string] : parse builds an object tree from the JSON.
+        on_test [script] :
+          tell ^^.payload to parse ( tests.objs.json.out )
+
+          eval tests.objs.json.out.title = 'Brute Force'
+          assert "expected parse to set the title"
+
+          eval tests.objs.json.out.meta.author = 'ESR'
+          assert "expected parse to build the nested meta container"
+
+      set_from_objects_round_trip [test] :
+        description [string] : set serialises an object tree; get reads it back.
+        on_test [script] :
+          # a path inside ( ) params must be absolute, not a ^ ref
+          tell ^^.built to set ( tests.objs.json.source )
+
+          tell ^^.built to get ( 'name' )
+          eval it = 'gloo'
+          assert "expected set then get to round-trip a value"
+
+      pretty_keeps_it_valid [test] :
+        description [string] : pretty reformats the text without breaking it.
+        on_test [script] :
+          tell ^^.compact to pretty
+          tell ^^.compact to get ( 'b.c' )
+          eval it = '2'
+          assert "expected the value to still be reachable after pretty"

data/test.gloo/objs/outline.test.gloo

@@ -0,0 +1,72 @@
+#
+# Outline object tests
+#
+# 'generate' turns a flat list of path-structured names into a nested
+# <ul>/<li> outline.  Each source item is a container whose first
+# child is the id and whose second child is the name.
+#
+
+tests [can] :
+  objs [can] :
+    outline [can] :
+
+      src [container] :
+        1 [container] :
+          id [int] : 1
+          name [string] : a/b/c
+        2 [container] :
+          id [int] : 2
+          name [string] : a/b/d
+        3 [container] :
+          id [int] : 3
+          name [string] : top
+
+      dotted [container] :
+        1 [container] :
+          id [int] : 9
+          name [string] : x.y.z
+
+      linked [outline] :
+        object_source [alias] : tests.objs.outline.src
+        entity_path [string] : /entity/
+        separator_char [string] : /
+        data [string] :
+
+      plain [outline] :
+        object_source [alias] : tests.objs.outline.dotted
+        separator_char [string] : .
+        data [string] :
+
+      builds_nested_html_with_links [test] :
+        description [string] : generate nests shared path segments and links leaves that have an id.
+        on_test [script] :
+          tell ^^.linked to generate
+
+          check ^^.linked.data for starts_with? ( "<ul>" )
+          assert "expected the outline to start with <ul>"
+
+          check ^^.linked.data for substring? ( "<li>a</li>" )
+          assert "expected a shared 'a' segment as a plain node"
+
+          check ^^.linked.data for substring? ( "<li>b</li>" )
+          assert "expected a shared 'b' segment as a plain node"
+
+          check ^^.linked.data for substring? ( "<a href='/entity/1'>c</a>" )
+          assert "expected leaf 'c' to be linked with its id and entity_path"
+
+          check ^^.linked.data for substring? ( "<a href='/entity/3'>top</a>" )
+          assert "expected the top-level 'top' item to be linked"
+
+      custom_separator_and_no_links [test] :
+        description [string] : separator_char sets the split char; with no entity_path leaves are plain.
+        on_test [script] :
+          tell ^^.plain to generate
+
+          check ^^.plain.data for substring? ( "<li>x</li>" )
+          assert "expected '.' to split x.y.z so 'x' is its own node"
+
+          check ^^.plain.data for substring? ( "<li>z</li>" )
+          assert "expected leaf 'z' rendered plain (no entity_path)"
+
+          check ^^.plain.data for substring? ( "href" )
+          refute "expected no links when entity_path is not set"

data/test.gloo/objs/password.test.gloo

@@ -0,0 +1,40 @@
+#
+# Password object tests
+#
+
+tests [can] :
+  objs [can] :
+    password [can] :
+
+      hash_and_check [test] :
+        description [string] : check succeeds for the right password and fails for the wrong one.
+        on_test [script] :
+          create tests.objs.password.p as password
+          put 'user-1' into tests.objs.password.p.salt
+          put 's3cret' into tests.objs.password.p.password
+          tell tests.objs.password.p to hash
+
+          check tests.objs.password.p.hash for blank?
+          refute "expected hash to be populated"
+
+          tell tests.objs.password.p to check
+          assert "expected check to pass for the original password"
+
+          put 'not the password' into tests.objs.password.p.password
+          tell tests.objs.password.p to check
+          refute "expected check to fail for a wrong password"
+
+      generate_length [test] :
+        description [string] : generate makes a password of the requested length and puts it in it.
+        on_test [script] :
+          create tests.objs.password.g as password
+
+          tell tests.objs.password.g to generate
+          tell tests.objs.password.g.password to size
+          eval it = 7
+          assert "expected the default generated length to be 7"
+
+          tell tests.objs.password.g to generate ( 20 )
+          tell tests.objs.password.g.password to size
+          eval it = 20
+          assert "expected the generated length to be 20"

data/test.gloo/objs/repeat.test.gloo

@@ -0,0 +1,48 @@
+#
+# Repeat object tests
+#
+
+tests [can] :
+  objs [can] :
+    repeat [can] :
+
+      count [int] : 0
+      seen [string] :
+
+      loop [repeat] :
+        times [integer] : 4
+        index [integer] : 0
+        do [script] :
+          put tests.objs.repeat.count + 1 into tests.objs.repeat.count
+          put tests.objs.repeat.seen + tests.objs.repeat.loop.index into tests.objs.repeat.seen
+
+      zero [repeat] :
+        times [integer] : 0
+        index [integer] : 0
+        do [script] :
+          put tests.objs.repeat.count + 100 into tests.objs.repeat.count
+
+      runs_the_do_script_n_times [test] :
+        description [string] : run executes 'do' once per 'times', and 'index' walks 0..times-1.
+        on_test [script] :
+          put 0 into ^^.count
+          put '' into ^^.seen
+
+          tell ^^.loop to run
+
+          eval ^^.count = 4
+          assert "expected the do script to run 4 times"
+
+          eval ^^.seen = '0123'
+          assert "expected index to be 0,1,2,3 across the iterations"
+
+          eval ^^.loop.index = 3
+          assert "expected index to be left at times-1 after the run"
+
+      zero_times_does_nothing [test] :
+        description [string] : run with times = 0 never executes 'do'.
+        on_test [script] :
+          put 0 into ^^.count
+          tell ^^.zero to run
+          eval ^^.count = 0
+          assert "expected the do script not to run when times is 0"

data/test.gloo/objs/untyped.test.gloo

@@ -1,12 +1,12 @@
 #
-# Script tests
+# Untyped object tests
 #
 
 tests [can] :
   objs [can] :
     untyped [can] :
 
-      a [any] : 
+      a [any] :
 
       test_untyped [test] :
         description [string] : Test untyped with different values
@@ -23,3 +23,21 @@ tests [can] :
           eval ^^.a = true
           assert "expected it to be true"
 
+      base_messages_work [test] :
+        description [string] : an untyped object still receives the base object messages
+        on_test [script] :
+          put "" into ^^.a
+          check ^^.a for blank?
+          assert "expected an empty untyped object to be blank"
+
+          put "x" into ^^.a
+          check ^^.a for blank?
+          refute "expected a non-empty untyped object to not be blank"
+
+      type_messages_do_not [test] :
+        description [string] : an untyped object does not receive type-specific messages
+        on_test [script] :
+          put "hello" into ^^.a
+          check ^^.a for responds_to? ( "up" )
+          refute "expected an untyped object to not respond to 'up'"
+

data/test.gloo/objs/uri.test.gloo

@@ -0,0 +1,43 @@
+#
+# URI object tests
+#
+
+tests [can] :
+  objs [can] :
+    uri [can] :
+
+      link [uri] : https://example.com:8443/docs/guide?page=3&sort=asc#install
+      bare [uri] : https://example.com
+
+      parts_of_a_url [test] :
+        description [string] : the get_ messages pull each piece of the URL into it.
+        on_test [script] :
+          tell ^^.link to get_scheme
+          eval it = 'https'
+          assert "expected scheme https"
+
+          tell ^^.link to get_host
+          eval it = 'example.com'
+          assert "expected host example.com (no port)"
+
+          tell ^^.link to get_path
+          eval it = '/docs/guide'
+          assert "expected path /docs/guide"
+
+          tell ^^.link to get_query
+          eval it = 'page=3&sort=asc'
+          assert "expected the query string"
+
+          tell ^^.link to get_fragment
+          eval it = 'install'
+          assert "expected fragment install"
+
+      missing_pieces [test] :
+        description [string] : a bare URL has an empty path.
+        on_test [script] :
+          tell ^^.bare to get_path
+          put it into tests.objs.uri.result
+          check tests.objs.uri.result for blank?
+          assert "expected the path of a bare URL to be blank"
+
+      result [string] :

data/test.gloo/verbs/context.test.gloo

@@ -0,0 +1,19 @@
+#
+# Context verb tests
+#
+
+tests [can] :
+  verbs [can] :
+    context [can] :
+
+      set_context [test] :
+        description [string] : context {path} sets the context and puts the path in it.
+        on_test [script] :
+          context tests.verbs.context
+          eval it = 'tests.verbs.context'
+          assert "expected it to be the new context path"
+
+          # restore, so later tests run at root
+          context root
+          eval it = 'root'
+          assert "expected context to be restored to root"

data/test.gloo/verbs/list.test.gloo

@@ -0,0 +1,34 @@
+#
+# List verb tests
+#
+# 'list' only writes to the console, so these tests check its error
+# behaviour rather than its output.
+#
+
+tests [can] :
+  verbs [can] :
+    list [can] :
+
+      data [can] :
+        a [string] : A
+        b [string] : B
+
+      err_fired [bool] : false
+      on_error [script] :
+        put true into ^.err_fired
+
+      list_real_container [test] :
+        description [string] : listing a real container does not fire on_error.
+        on_test [script] :
+          put false into ^^.err_fired
+          list tests.verbs.list.data
+          eval ^^.err_fired = false
+          assert "listing a real container should not fire on_error"
+
+      list_missing_target [test] :
+        description [string] : listing a missing target fires on_error.
+        on_test [script] :
+          put false into ^^.err_fired
+          list tests.verbs.list.no_such_thing
+          eval ^^.err_fired = true
+          assert "listing a missing target should fire on_error"

data/test.gloo/verbs/load.test.gloo

@@ -0,0 +1,32 @@
+#
+# Load verb tests
+#
+# Uses 'load lib' because it is self-contained (no fixture files) and
+# its effect is observable through 'exists?'.
+#
+
+tests [can] :
+  verbs [can] :
+    load [can] :
+
+      err_fired [bool] : false
+      on_error [script] :
+        put true into ^.err_fired
+
+      load_lib_registers_type [test] :
+        description [string] : load lib registers that library's object types.
+        on_test [script] :
+          exists? object markdown
+          refute "markdown type should not be registered before load"
+
+          load lib md
+          exists? object markdown
+          assert "expected the markdown type to be registered after 'load lib md'"
+
+      load_no_args_errors [test] :
+        description [string] : load with no arguments fires on_error.
+        on_test [script] :
+          put false into ^^.err_fired
+          load
+          eval ^^.err_fired = true
+          assert "expected 'load' with no arguments to fire on_error"