puppet 4.7.1 → 4.8.0

data/spec/unit/pops/parser/parse_functions_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'puppet/pops'
+require_relative 'parser_rspec_helper'
+
+describe 'egrammar parsing function definitions' do
+  include ParserRspecHelper
+
+  context 'without return type' do
+    it 'function foo() { 1 }' do
+      expect(dump(parse('function foo() { 1 }'))).to eq("(function foo (block\n  1\n))")
+    end
+  end
+
+  context 'with return type' do
+    it 'function foo() >> Integer { 1 }' do
+      expect(dump(parse('function foo() >> Integer { 1 }'))).to eq("(function foo (return_type integer) (block\n  1\n))")
+    end
+  end
+end

data/spec/unit/pops/parser/parse_lambda_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'puppet/pops'
+require_relative 'parser_rspec_helper'
+
+describe 'egrammar parsing lambda definitions' do
+  include ParserRspecHelper
+
+  context 'without return type' do
+    it 'f() |$x| { 1 }' do
+      expect(dump(parse('f() |$x| { 1 }'))).to eq("(invoke f (lambda (parameters x) (block\n  1\n)))")
+    end
+  end
+
+  context 'with return type' do
+    it 'f() |$x| >> Integer { 1 }' do
+      expect(dump(parse('f() |$x| >> Integer { 1 }'))).to eq("(invoke f (lambda (parameters x) (return_type integer) (block\n  1\n)))")
+    end
+  end
+end

data/spec/unit/pops/puppet_stack_spec.rb

@@ -50,7 +50,7 @@ describe 'Puppet::Pops::PuppetStack' do
   end
 
   it 'returns an array from stacktrace with information about each level with oldest frame last' do
-    expect(StackTraceTest.new.two_levels).to eql([['two_levels.pp', 1237], ['level2.pp', 1240]])
+    expect(StackTraceTest.new.two_levels).to eql([['level2.pp', 1240], ['two_levels.pp', 1237]])
   end
 
   it 'accepts file to be nil' do

data/spec/unit/pops/resource/resource_type_impl_spec.rb

@@ -1,6 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
+require 'puppet_spec/files'
 require 'puppet_spec/compiler'
 
 module Puppet::Pops
@@ -32,6 +33,79 @@ describe "Puppet::Pops::Resource" do
       expect(rt.valid_parameter?(:loglevel)).to be_truthy
     end
   end
+
+
+  context 'when used with capability resource with producers/consumers' do
+    include PuppetSpec::Files
+
+    let!(:env_name) { 'spec' }
+    let!(:env_dir) { tmpdir('environments') }
+    let!(:populated_env_dir) do
+      dir_contained_in(env_dir, env_name => {
+        '.resource_types' => {
+          'capability.pp' => <<-PUPPET
+            Puppet::Resource::ResourceType3.new(
+              'capability',
+              [],
+              [Puppet::Resource::Param(Any, 'name', true)],
+              { /(.*)/ => ['name'] },
+              true,
+              true)
+        PUPPET
+        },
+        'modules' => {
+          'test' => {
+            'lib' => {
+              'puppet' => {
+                'type' => { 'capability.rb' => <<-RUBY
+                  Puppet::Type.newtype(:capability, :is_capability => true) do
+                    newparam :name, :namevar => true
+                    raise Puppet::Error, 'Ruby resource was loaded'
+                  end
+                RUBY
+                }
+              }
+            }
+          }
+        }
+      })
+    end
+
+    let!(:code) { <<-PUPPET }
+      define producer() {
+        notify { "producer":}
+      }
+
+      define consumer() {
+        notify { $title:}
+      }
+
+      Producer produces Capability {}
+
+      Consumer consumes Capability {}
+
+      producer {x: export => Capability[cap]}
+      consumer {x: consume => Capability[cap]}
+      consumer {y: require => Capability[cap]}
+    PUPPET
+
+    let(:environments) { Puppet::Environments::Directories.new(populated_env_dir, []) }
+    let(:env) { Puppet::Node::Environment.create(:'spec', [File.join(env_dir, 'spec', 'modules')]) }
+    let(:node) { Puppet::Node.new('test', :environment => env) }
+    around(:each) do |example|
+      Puppet[:app_management] = true
+      Puppet[:environment] = env_name
+      Puppet.override(:environments => environments, :current_environment => env) do
+        example.run
+      end
+      Puppet::Type.rmtype(:capability)
+      Puppet[:app_management] = false
+    end
+
+    it 'does not load the Ruby resource' do
+      expect { compile_to_catalog(code, node) }.not_to raise_error
+    end
+  end
 end
 end
 end

data/spec/unit/pops/serialization/packer_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 require 'puppet/pops/serialization'
 
-module Puppet::Pops::Serialization
+module Puppet::Pops
+module Serialization
 [JSON].each do |packer_module|
 describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
   let(:io) { StringIO.new }
@@ -21,7 +22,7 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
     count.nil? ? @deserializer.read : Array.new(count) { @deserializer.read }
   end
 
-  context 'can write and read a Scalar' do
+  context 'can write and read a' do
     it 'String' do
       val = 'the value'
       write(val)
@@ -86,11 +87,28 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
       expect(val2).to eql(val)
     end
 
-    it 'Time created by TimeFactory' do
-      val = TimeFactory.now
+    it 'Sensitive' do
+      sval = 'the sensitive value'
+      val = Types::PSensitiveType::Sensitive.new(sval)
       write(val)
       val2 = read
-      expect(val2).to be_a(Time)
+      expect(val2).to be_a(Types::PSensitiveType::Sensitive)
+      expect(val2.unwrap).to eql(sval)
+    end
+
+    it 'Timespan' do
+      val = Time::Timespan.from_fields(false, 3, 12, 40, 31, 123)
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Time::Timespan)
+      expect(val2).to eql(val)
+    end
+
+    it 'Timestamp' do
+      val = Time::Timestamp.now
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Time::Timestamp)
       expect(val2).to eql(val)
     end
 
@@ -110,21 +128,22 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
       expect(val2).to eql(val)
     end
 
-    it 'will never fail write and read of Time created by TimeFactory' do
-      val = Time.now
-      val = TimeFactory.at(val.tv_sec, val.tv_nsec / 1000 + 0.123)
+    it 'Binary' do
+      val = Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
       write(val)
       val2 = read
-      expect(val).to eq(val2)
+      expect(val2).to be_a(Types::PBinaryType::Binary)
+      expect(val2).to eql(val)
     end
 
-    # Windows doesn't seem ot have fine enough granularity to provoke the problem
-    it 'will fail on Time not created by TimeFactory' do
-      val = Time.now
-      val = Time.at(val.tv_sec, val.tv_nsec / 1000 + 0.123)
+    it 'Sensitive with rich data' do
+      sval = Time::Timestamp.now
+      val = Types::PSensitiveType::Sensitive.new(sval)
       write(val)
       val2 = read
-      expect(val).not_to eq(val2)
+      expect(val2).to be_a(Types::PSensitiveType::Sensitive)
+      expect(val2.unwrap).to be_a(Time::Timestamp)
+      expect(val2.unwrap).to eql(sval)
     end
   end
 
@@ -151,3 +170,4 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
 end
 end
 end
+end

data/spec/unit/pops/serialization/serialization_spec.rb

@@ -37,7 +37,7 @@ module Serialization
     parser.parse_string(string, '/home/tester/experiments/manifests/init.pp').current
   end
 
-  context 'can write and read a Scalar' do
+  context 'can write and read a' do
     it 'String' do
       val = 'the value'
       write(val)
@@ -94,12 +94,28 @@ module Serialization
       expect(val2).to eql(val)
     end
 
-    it 'Time created by TimeFactory' do
-      # It does succeed on rare occasions, so we need to repeat
-      val = TimeFactory.now
+    it 'Sensitive' do
+      sval = 'the sensitive value'
+      val = Types::PSensitiveType::Sensitive.new(sval)
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Types::PSensitiveType::Sensitive)
+      expect(val2.unwrap).to eql(sval)
+    end
+
+    it 'Timespan' do
+      val = Time::Timespan.from_fields(false, 3, 12, 40, 31, 123)
       write(val)
       val2 = read
-      expect(val2).to be_a(Time)
+      expect(val2).to be_a(Time::Timespan)
+      expect(val2).to eql(val)
+    end
+
+    it 'Timestamp' do
+      val = Time::Timestamp.now
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Time::Timestamp)
       expect(val2).to eql(val)
     end
 
@@ -120,6 +136,24 @@ module Serialization
       expect(val2).to be_a(Semantic::VersionRange)
       expect(val2).to eql(val)
     end
+
+    it 'Binary' do
+      val = Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Types::PBinaryType::Binary)
+      expect(val2).to eql(val)
+    end
+
+    it 'Sensitive with rich data' do
+      sval = Time::Timestamp.now
+      val = Types::PSensitiveType::Sensitive.new(sval)
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Types::PSensitiveType::Sensitive)
+      expect(val2.unwrap).to be_a(Time::Timestamp)
+      expect(val2.unwrap).to eql(sval)
+    end
   end
 
   context 'can write and read' do
@@ -169,6 +203,34 @@ module Serialization
       end
     end
 
+    it 'Array of rich data' do
+      # Sensitive omitted because it doesn't respond to ==
+      val = [
+        Time::Timespan.from_fields(false, 3, 12, 40, 31, 123),
+        Time::Timestamp.now,
+        Semantic::Version.parse('1.2.3-alpha2'),
+        Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
+        Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+      ]
+      write(val)
+      val2 = read
+      expect(val2).to eql(val)
+    end
+
+    it 'Hash of rich data' do
+      # Sensitive omitted because it doesn't respond to ==
+      val = {
+        'duration' => Time::Timespan.from_fields(false, 3, 12, 40, 31, 123),
+        'time' => Time::Timestamp.now,
+        'version' => Semantic::Version.parse('1.2.3-alpha2'),
+        'range' => Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
+        'binary' => Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+      }
+      write(val)
+      val2 = read
+      expect(val2).to eql(val)
+    end
+
     context 'an AST model' do
       it "Locator" do
         val = Parser::Locator::Locator19.new('here is some text', '/tmp/foo', [5])

data/spec/unit/pops/time/timespan_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Time
+describe 'Timespan' do
+  include PuppetSpec::Compiler
+
+  let! (:simple) { Timespan.from_fields(false, 1, 3, 10, 11) }
+  let! (:all_fields_hash) { {'days' => 1, 'hours' => 7, 'minutes' => 10, 'seconds' => 11, 'milliseconds' => 123, 'microseconds' => 456, 'nanoseconds' => 789} }
+  let! (:complex) { Timespan.from_fields_hash(all_fields_hash) }
+
+  context 'can be created from a String' do
+    it 'using default format' do
+      expect(Timespan.parse('1-03:10:11')).to eql(simple)
+    end
+
+    it 'using explicit format' do
+      expect(Timespan.parse('1-7:10:11.123456789', '%D-%H:%M:%S.%N')).to eql(complex)
+    end
+
+    it 'using leading minus and explicit format' do
+      expect(Timespan.parse('-1-7:10:11.123456789', '%D-%H:%M:%S.%N')).to eql(-complex)
+    end
+
+    it 'using %H as the biggest quantity' do
+      expect(Timespan.parse('27:10:11', '%H:%M:%S')).to eql(simple)
+    end
+
+    it 'using %M as the biggest quantity' do
+      expect(Timespan.parse('1630:11', '%M:%S')).to eql(simple)
+    end
+
+    it 'using %S as the biggest quantity' do
+      expect(Timespan.parse('97811', '%S')).to eql(simple)
+    end
+
+    it 'where biggest quantity is not frist' do
+      expect(Timespan.parse('11:1630', '%S:%M')).to eql(simple)
+    end
+
+    it 'raises an error when using %L as the biggest quantity' do
+      expect { Timespan.parse('123', '%L') }.to raise_error(ArgumentError, /denotes fractions and must be used together with a specifier of higher magnitude/)
+    end
+
+    it 'raises an error when using %N as the biggest quantity' do
+      expect { Timespan.parse('123', '%N') }.to raise_error(ArgumentError, /denotes fractions and must be used together with a specifier of higher magnitude/)
+    end
+
+    it 'where %L is treated as fractions of a second' do
+      expect(Timespan.parse('0.4', '%S.%L')).to eql(Timespan.from_fields(false, 0, 0, 0, 0, 400))
+    end
+
+    it 'where %N is treated as fractions of a second' do
+      expect(Timespan.parse('0.4', '%S.%N')).to eql(Timespan.from_fields(false, 0, 0, 0, 0, 400))
+    end
+  end
+
+  context 'when presented as a String' do
+    it 'uses default format for #to_s' do
+      expect(simple.to_s).to eql('1-03:10:11.0')
+    end
+
+    context 'using a format' do
+      it 'produces a string containing all components' do
+        expect(complex.format('%D-%H:%M:%S.%N')).to eql('1-07:10:11.123456789')
+      end
+
+      it 'produces a literal % for %%' do
+        expect(complex.format('%D%%%H:%M:%S')).to eql('1%07:10:11')
+      end
+
+      it 'produces a leading dash for negative instance' do
+        expect((-complex).format('%D-%H:%M:%S')).to eql('-1-07:10:11')
+      end
+
+      it 'produces a string without trailing zeros for %-N' do
+        expect(Timespan.parse('2.345', '%S.%N').format('%-S.%-N')).to eql('2.345')
+      end
+
+      it 'produces a string with trailing zeros for %N' do
+        expect(Timespan.parse('2.345', '%S.%N').format('%-S.%N')).to eql('2.345000000')
+      end
+
+      it 'produces a string with trailing zeros for %0N' do
+        expect(Timespan.parse('2.345', '%S.%N').format('%-S.%0N')).to eql('2.345000000')
+      end
+
+      it 'produces a string with trailing spaces for %_N' do
+        expect(Timespan.parse('2.345', '%S.%N').format('%-S.%_N')).to eql('2.345      ')
+      end
+    end
+  end
+
+  context 'when converted to a hash' do
+    it 'produces a hash with all numeric keys' do
+      hash = complex.to_hash
+      expect(hash).to eql(all_fields_hash)
+    end
+
+    it 'produces a compact hash with seconds and nanoseconds for #to_hash(true)' do
+      hash = complex.to_hash(true)
+      expect(hash).to eql({'seconds' => 112211, 'nanoseconds' => 123456789})
+    end
+
+    context 'from a negative value' do
+      it 'produces a hash with all numeric keys and negative = true' do
+        hash = (-complex).to_hash
+        expect(hash).to eql(all_fields_hash.merge('negative' => true))
+      end
+
+      it 'produces a compact hash with negative seconds and negative nanoseconds for #to_hash(true)' do
+        hash = (-complex).to_hash(true)
+        expect(hash).to eql({'seconds' => -112211, 'nanoseconds' => -123456789})
+      end
+    end
+  end
+end
+end
+end

data/spec/unit/pops/types/p_binary_type_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+describe 'Binary Type' do
+  include PuppetSpec::Compiler
+
+  context 'as a type' do
+    it 'can be created with the type factory' do
+      t = TypeFactory.binary()
+      expect(t).to be_a(PBinaryType)
+      expect(t).to eql(PBinaryType::DEFAULT)
+    end
+  end
+
+  context 'a Binary instance' do
+    it 'can be created from a raw String using %r, raw string mode' do
+      str = [0xF1].pack("C*")
+      code = <<-CODE
+        $x = Binary($testing, '%r')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code, Puppet::Node.new('foonode'), { 'testing' => str })).to eql(['8Q=='])
+    end
+
+    it 'can be created from a String using %s, string mode' do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary('binary', '%s')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXJ5'])
+    end
+
+    it 'format %s errors if encoding is bad in given string when using format %s and a broken UTF-8 string' do
+      str = [0xF1].pack("C*")
+      str.force_encoding('UTF-8')
+      code = <<-CODE
+        $x = Binary($testing, '%s')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect {
+        eval_and_collect_notices(code, Puppet::Node.new('foonode'), { 'testing' => str })
+      }.to raise_error(/.*The given string in encoding 'UTF-8' is invalid\. Cannot create a Binary UTF-8 representation.*/)
+    end
+
+    it 'format %s errors if encoding is correct but string cannot be transcoded to UTF-8' do
+      str = [0xF1].pack("C*")
+      code = <<-CODE
+        $x = Binary($testing, '%s')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect {
+        eval_and_collect_notices(code, Puppet::Node.new('foonode'), { 'testing' => str })
+      }.to raise_error(/.*"\\xF1" from ASCII-8BIT to UTF-8.*/)
+    end
+
+    it 'can be created from a strict Base64 encoded String using default format' do
+      code = <<-CODE
+        $x = Binary('YmluYXI=')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXI='])
+    end
+
+    it 'will error creation in strict mode if padding is missing when using default format' do
+      # the text 'binar' needs padding with '=' (missing here to trigger error
+      code = <<-CODE
+        $x = Binary('YmluYXI')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect{ eval_and_collect_notices(code) }.to raise_error(/invalid base64/)
+    end
+
+    it 'can be created from a Base64 encoded String using %B, strict mode' do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary('YmluYXI=', '%B')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXI='])
+    end
+
+    it 'will error creation in strict mode if padding is missing' do
+      # the text 'binar' needs padding with '=' (missing here to trigger error
+      code = <<-CODE
+        $x = Binary('YmluYXI', '%B')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect{ eval_and_collect_notices(code) }.to raise_error(/invalid base64/)
+    end
+
+    it 'will not error creation in base mode if padding is missing' do
+      # the text 'binar' needs padding with '=' (missing here to trigger possible error)
+      code = <<-CODE
+        $x = Binary('YmluYXI', '%b')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXI='])
+    end
+
+    it 'will not error creation in base mode if padding is not required' do
+      # the text 'binary' does not need padding with '='
+      code = <<-CODE
+        $x = Binary('YmluYXJ5', '%b')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXJ5'])
+    end
+
+    it 'can be compared to another instance for equality' do
+      code = <<-CODE
+        $x = Binary('YmluYXJ5')
+        $y = Binary('YmluYXJ5')
+        notice($x == $y)
+        notice($x != $y)
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'false'])
+    end
+
+    it 'can be created from an array of byte values' do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary([251, 239, 255])
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['++//'])
+    end
+
+    it "can be created from an hash with value and format" do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary({value => '--__', format => '%u'})
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['++//'])
+    end
+
+    it "can be created from an hash with value and default format" do
+      code = <<-CODE
+        $x = Binary({value => 'YmluYXI='})
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXI='])
+    end
+
+    it 'can be created from a hash with value being an array' do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary({value => [251, 239, 255]})
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['++//'])
+    end
+
+    it "can be created from an Base64 using URL safe encoding by specifying '%u' format'" do
+      # the text 'binar' needs padding with '='
+      code = <<-CODE
+        $x = Binary('--__', '%u')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['++//'])
+    end
+
+    it "when created with URL safe encoding chars in '%b' format, these are skipped" do
+      code = <<-CODE
+        $x = Binary('--__YmluYXJ5', '%b')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['YmluYXJ5'])
+    end
+
+    it "will error in strict format if string contains URL safe encoded chars" do
+      code = <<-CODE
+        $x = Binary('--__YmluYXJ5', '%B')
+        notice(assert_type(Binary, $x))
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(/invalid base64/)
+    end
+
+    [   '<',
+        '<=',
+        '>',
+        '>='
+    ].each do |op|
+      it "cannot be compared to another instance for magnitude using #{op}" do
+        code = <<-"CODE"
+          $x = Binary('YmluYXJ5')
+          $y = Binary('YmluYXJ5')
+          $x #{op} $y
+        CODE
+        expect { eval_and_collect_notices(code)}.to raise_error(/Comparison of: Binary #{op} Binary, is not possible/)
+      end
+    end
+
+    it 'can be matched against a Binary in case expression' do
+      code = <<-CODE
+        case Binary('YmluYXJ5') {
+          Binary('YWxpZW4='): {
+            notice('nope')
+          }
+          Binary('YmluYXJ5'): {
+            notice('yay')
+          }
+          default: {
+            notice('nope')
+          }
+        }
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['yay'])
+    end
+
+    it "can be matched against a Binary subsequence using 'in' expression" do
+      # finding 'one' in 'one two three'
+      code = <<-CODE
+        notice(Binary("b25l") in Binary("b25lIHR3byB0aHJlZQ=="))
+        notice(Binary("c25l") in Binary("b25lIHR3byB0aHJlZQ=="))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'false'])
+    end
+
+    it "can be matched against a byte value using 'in' expression" do
+      # finding 'e' (ascii 101) in 'one two three'
+      code = <<-CODE
+        notice(101 in Binary("b25lIHR3byB0aHJlZQ=="))
+        notice(101.0 in Binary("b25lIHR3byB0aHJlZQ=="))
+        notice(102 in Binary("b25lIHR3byB0aHJlZQ=="))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'true', 'false'])
+    end
+
+    it "has a length method in ruby returning the length measured in bytes" do
+      # \u{1f452} is "woman's hat emoji - 4 bytes in UTF-8"
+      a_binary = PBinaryType::Binary.new("\u{1f452}")
+      expect(a_binary.length).to be(4)
+    end
+  end
+
+end
+end
+end