Puppet Community

yeah one last minor release will be cut be before cutting the major release with Pupept 8/deprecated functions removed :slightly_smiling_face:

i went a bit tally-ho with making function delete PRs….

<@U1PC2RAH0> <https://github.com/voxpupuli/metadata-json-lint/pull/128>

small dependency conflict being caused by metadata-lint. I purposefully did bump it past v5 but can do if you think that is safe.

Any chance of getting this released too :slightly_smiling_face:

hopefully i’ll be able to stop spamming you for a while after this

<@U0332SZQLKZ> <https://github.com/voxpupuli/metadata-json-lint/pull/129>

<https://github.com/voxpupuli/metadata-json-lint/pull/130>

So once i merge this, i just hit your release workflow?

you can merge, create a tag on the CLI (check with git tag -l if previous tags had a prefixed `v` or not and follow the pattern), push the tag. github will trigger a release with that tag

<@U114TKH5M> I just looked at that PDK issue you posted a while back.. it’s actually being caused by a third party thing

<https://github.com/Accuity/rspec-puppet-utils>

It’s likely that the gem hasn’t kept up with changes etc

<@U0332SZQLKZ> that's kind of what I thought, but I figured someone else had to be mocking functions with 2.6.1 and above and maybe there was a better - and compatible - way to do it.

wonder if the stuff in there would fit in rspec-puppet

This is one of those big pieces of cruft, so I'm going to comment it out and see what happens :smile:

So removing rspec-puppet-utils killed it, but not as bad as I thought <@U0332SZQLKZ>

however it did kill my browser... so here's a screenshot until I get the raw logs, stupid jenkins, lol

```[2023-04-24T14:57:00.478Z]   1) ahchocolatey on windows-2012 R2-x86_64 
[2023-04-24T14:57:00.478Z]      Failure/Error:
[2023-04-24T14:57:00.478Z]        MockFunction.new('vault_lookup') do |f|
[2023-04-24T14:57:00.478Z]          f.stubbed.returns(domain: 'prod',
[2023-04-24T14:57:00.478Z]                            username: 'test',
[2023-04-24T14:57:00.478Z]                            password: 'test')
[2023-04-24T14:57:00.478Z]        end
[2023-04-24T14:57:00.478Z] 
[2023-04-24T14:57:00.478Z]      NameError:
[2023-04-24T14:57:00.478Z]        uninitialized constant MockFunction```

yeah that code wont be there anymore since it was provided by the rspec utils gem you were using

you’ll have to remove that mock function from your tests or get the owner to update their gem

<https://rspec-puppet.com/documentation/functions/> talks about how to test a function, but I can't seem to find how to mock one.

you might have to monkey patch it (if that is even possible)

or just take the MockFunction code and make it work

how would you do that though? There's like 800 ways described in google results but I'm not sure what's the right way. This is a part of rspec-puppet that I've never understood.

I’m not actually sure if what i said was possible.. because you’d have to make puppet load your mocked function

<https://github.com/Accuity/rspec-puppet-utils/blob/master/lib/rspec_puppet_utils/mock_function.rb>

but obviously the stub thing is tripping you up because it’s removed

there's nothing built in for that though?

`allow(scope).to receive(:lookupvar).with('some_variable').and_return('some value')` seems like it might work but I'm not sure how or where to put that in spec/spec_helper_local.rb so it applies everywhere, instead of adding it to every file.

<https://github.com/Accuity/rspec-puppet-utils/blob/45e7612491e15fbcb073e06962d7e5d7d5c5535c/lib/rspec_puppet_utils/mock_function.rb#L38>

this must be the line that causes your issue

check your rpsec config in your spec_helper

but im pretty sure later versions of pdk-templates updates this

you’ll need to re-add your utils gem though

This is one of the things I wish was better documented.  using hiera in tests and mocking functions/external dependencies

```RSpec.configure do |c|
  c.before :each do
    if ENV['PUPPET_DEBUG']
      Puppet::Util::Log.level = :debug
      Puppet::Util::Log.newdestination(:console)
    end

    # MockFunction.new('vault_lookup') do |f|
    #   f.stubbed.returns(domain: 'prod',
    #                     username: 'test',
    #                     password: 'test')
    # end

    allow(scope).to receive(:vault_lookup).and_return({
      domain: 'prod',
      username: 'test',
      password: 'test'
    })
    allow_any_instance_of(Puppet::Type.type(:acl).provider(:windows)).to receive(:validate)                                              # rubocop:disable RSpec/AnyInstance
    allow_any_instance_of(Puppet::Type.type(:acl).provider(:windows)).to receive(:respond_to?).with(:get_account_name).and_return(false) # rubocop:disable RSpec/AnyInstance
    allow_any_instance_of(Puppet::Type.type(:acl).provider(:windows)).to receive(:respond_to?).with(:get_group_name).and_return(false)   # rubocop:disable RSpec/AnyInstance
    allow_any_instance_of(Puppet::Type.type(:acl).provider(:windows)).to receive(:respond_to?).with(:validate).and_return(true)          # rubocop:disable RSpec/AnyInstance
  end
end```

i have NO IDEA if that's the right syntax but I'm going off what <http://rspec-puppet.com|rspec-puppet.com> had

```  before(:each) do
    Puppet::Parser::Functions.newfunction(:'module::group_lookup', type: :rvalue) do |args|
      "cn=#{args[0]}"
    end
  end```

this is... likely very very wrong... but it does work

Thats basically what the utils gem was doing

and it’s also how you would define a new function

I guess you just need to make sure you are not leaking it

it's literally a before on each spec file/group I need it on

which is super not DRY, but safe for someone who has no idea how to rspec test

that's the hardest part about rspec-puppet to me, I feel like a large % of people doing rspec-puppet don't really know ruby, they just know puppet and super basic rspec for puppet

and a really good attempt was made in the past

<@U020LK7D0JU> any idea how to do that if it's supposed to return a hash?

it's just a ruby function, so just building a variable then just putting only the variable on a line should work

would I just replace `"cn=#{args[0]}"` with it?

kind of what I thought but here be dragons and all that

ruby does this oddity where if you put a variable or value alone on a line

and rubocop actively bitches if you use the return keyword

i get why it's used, but also I don't care :smile:

ruby is also not my favorite syntax design to begin with

okay 4 commits later and I'm past rubocop, now I can find out if it works haha

```[2023-04-24T15:25:13.862Z] FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF****FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF********FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF****FFFFFFFFFFFFFFFFFFFFFFFF****FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF****FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF****FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF****FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF```

my tests look like that entirely too often

trying this now
```    Puppet::Parser::Functions.newfunction(:'vault_lookup', type: :rvalue) do |args|
      {
        domain: 'prod'
        username: 'test'
        password: 'test'
      }
    end```

that may have issues around data type too Sensitive / node_encrypt etc

lol
```11:28:58  pdk (ERROR): rubocop: unexpected token tIDENTIFIER
11:28:58  (Using Ruby 2.5 parser; configure using `TargetRubyVersion` parameter, under `AllCops`) (spec/spec_helper_local.rb:20:9)```
Guess I need commas between the lines?

Perfect. Rubocop complained about hte unused `|args|` so I took them out... and now I get this :smile:

```[2023-04-24T15:45:32.814Z]   2) profile::barcode on windows-2012 R2-x86_64 is expected to contain File[c:/temp]
[2023-04-24T15:45:32.814Z]      Failure/Error:
[2023-04-24T15:45:32.814Z]        Puppet::Parser::Functions.newfunction(:vault_lookup, type: :rvalue) do
[2023-04-24T15:45:32.814Z]          {
[2023-04-24T15:45:32.814Z]            domain: 'prod',
[2023-04-24T15:45:32.814Z]            username: 'test',
[2023-04-24T15:45:32.814Z]            password: 'test'
[2023-04-24T15:45:32.814Z]          }
[2023-04-24T15:45:32.814Z]        end
[2023-04-24T15:45:32.814Z] 
[2023-04-24T15:45:32.814Z]      Puppet::PreformattedError:
[2023-04-24T15:45:32.814Z]        Evaluation Error: Error while evaluating a Function Call, wrong number of arguments (given 1, expected 0) (file: /var/lib/jenkins/workspace/EXSRE_puppet-controlrepo_utils/spec/fixtures/modules/profile/manifests/barcode.pp, line: 11, column: 25) on node <http://6a5f4e8fbe20.us-east-1.aws.athenahealth.com|6a5f4e8fbe20.us-east-1.aws.athenahealth.com>
[2023-04-24T15:45:32.814Z]      # /opt/puppetlabs/pdk/private/ruby/2.7.6/lib/ruby/2.7.0/benchmark.rb:308:in `realtime'
[2023-04-24T15:45:32.814Z]      # ./spec/classes/profile/barcode_spec.rb:12:in `block (4 levels) in &lt;top (required)&gt;'
[2023-04-24T15:45:32.814Z]      # ------------------
[2023-04-24T15:45:32.814Z]      # --- Caused by: ---
[2023-04-24T15:45:32.814Z]      # ArgumentError:
[2023-04-24T15:45:32.814Z]      #   wrong number of arguments (given 1, expected 0)
[2023-04-24T15:45:32.814Z]      #   /opt/puppetlabs/pdk/private/ruby/2.7.6/lib/ruby/2.7.0/benchmark.rb:308:in `realtime'
[2023-04-24T15:45:32.814Z] ```

that said it looks like it's handling it as a function so that's progress!

that's probably a bug to report for puppet rubocop

you can’t take out that arg <@U114TKH5M>

(I mean, the configuration for pdk/modulesync

ah I went with `Puppet::Parser::Functions.newfunction(:vault_lookup, type: :rvalue) do |args| # rubocop:disable Lint/UnusedArgument`, if it works I'll go back and change it

even just documenting that in the rspec-puppet (knowing a lot of people writing puppet rspec won't know rspec more general

if that works I'll be applying it to a bunch of my work

just catching up on this thread, but I just ran into a similar issue for `vault_lookup::lookup()`, and couldn't figure out how to mock a `Deferred` function call correctly, so I did this instead, which works:
• <https://github.com/voxpupuli/puppet-vault_lookup/pull/77>
<@U114TKH5M> just confirming, but what worked for you?

The last - I’ll post some changes here after lunch when I tidy it up

<@U114TKH5M> if you could provide a docs PR to rspec-puppet I would be more than happy to merge it!

So wait... the fix is to stub it as a legacy-API function?
e.g:
```Puppet::Parser::Functions.newfunction()```
As opposed to stubbing it as a modern-API function?
e.g.
```Puppet::Functions.create_function()```

both likely work? it's more a function of just trying to  figure out how to get it to work, if we can document the _right_ way to do it in rspec/mocha then :heart:

I know that the latter (the modern API) does not work. Haven't figured out why though.

I shared what I had because it worked, not because it was _right_

oh I know :slightly_smiling_face: No worries.
I just wanted to clarify what the working solution was.

Though I do think that stubbing a modern-API function as a legacy-API function will probably have some unintended side effects, probably in weird edge cases, that might be hard to track down.
So I wonder if it's something that should be recommended in general

Releasing a new version of vault_lookup. For review please:
• <https://github.com/voxpupuli/puppet-vault_lookup/pull/79>

Are host options in Beaker documented anywhere? I mean the `host` argument here: `provision(host, options)`.. any docs for `options` would be nice too :slightly_smiling_face: but as far as I see every hypervisor is free to do whatever they want..

Reading sources is nice and bumping my experience but it’d be much nicer to have some internal docs :slightly_smiling_face: