File: deep_implode_spec.rb

package info (click to toggle)
puppet-module-voxpupuli-elasticsearch 9.0.0-3
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 1,496 kB
  • sloc: ruby: 9,906; sh: 392; makefile: 4
file content (134 lines) | stat: -rw-r--r-- 5,276 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
# frozen_string_literal: true

require 'spec_helper'
describe 'deep_implode' do
  describe 'exception handling' do
    it {
      expect(subject).to run.with_params.and_raise_error(
        Puppet::ParseError, %r{wrong number of arguments}i
      )
    }

    it {
      expect(subject).to run.with_params({}, {}).and_raise_error(
        Puppet::ParseError, %r{wrong number of arguments}i
      )
    }

    it {
      expect(subject).to run.with_params('2').and_raise_error(
        Puppet::ParseError, %r{unexpected argument type}
      )
    }
  end

  ['value', ['value'], 0, 10].each do |value|
    describe "qualifying #{value}" do
      it { is_expected.to run.with_params({}).and_return({}) }

      it {
        expect(subject).to run.with_params({
                                             'key' => value
                                           }).and_return({
                                                           'key' => value
                                                         })
      }

      it {
        expect(subject).to run.with_params({
                                             'key' => { 'subkey' => value }
                                           }).and_return({
                                                           'key.subkey' => value
                                                         })
      }

      it {
        expect(subject).to run.with_params({
                                             'key' => { 'subkey' => { 'subsubkey' => { 'bottom' => value } } }
                                           }).and_return({
                                                           'key.subkey.subsubkey.bottom' => value
                                                         })
      }
    end
  end

  # The preferred behavior is to favor fully-qualified keys
  describe 'key collisions' do
    it {
      expect(subject).to run.with_params({
                                           'key1' => {
                                             'subkey1' => 'value1'
                                           },
                                           'key1.subkey1' => 'value2'
                                         }).and_return({
                                                         'key1.subkey1' => 'value2'
                                                       })
    }

    it {
      expect(subject).to run.with_params({
                                           'key1.subkey1' => 'value2',
                                           'key1' => {
                                             'subkey1' => 'value1'
                                           }
                                         }).and_return({
                                                         'key1.subkey1' => 'value2'
                                                       })
    }
  end

  describe 'deep merging' do
    it {
      expect(subject).to run.with_params({
                                           'key1' => {
                                             'subkey1' => ['value1']
                                           },
                                           'key1.subkey1' => ['value2']
                                         }).and_return({
                                                         'key1.subkey1' => %w[value2 value1]
                                                       })
    }

    it {
      expect(subject).to run.with_params({
                                           'key1' => {
                                             'subkey1' => { 'key2' => 'value1' }
                                           },
                                           'key1.subkey1' => { 'key3' => 'value2' }
                                         }).and_return({
                                                         'key1.subkey1.key2' => 'value1',
                                                         'key1.subkey1.key3' => 'value2'
                                                       })
    }

    it {
      expect(subject).to run.with_params({
                                           'key1' => {
                                             'subkey1' => { 'key2' => ['value1'] }
                                           },
                                           'key1.subkey1' => { 'key2' => ['value2'] }
                                         }).and_return({
                                                         'key1.subkey1.key2' => %w[value2 value1]
                                                       })
    }

    it {
      expect(subject).to run.with_params({
                                           'key1' => {
                                             'subkey1' => { 'key2' => 'value1' },
                                             'subkey1.key2' => 'value2'
                                           }
                                         }).and_return({
                                                         'key1.subkey1.key2' => 'value2'
                                                       })
    }
  end

  it 'does not change the original hashes' do
    argument1 = { 'key1' => 'value1' }
    original1 = argument1.dup

    subject.execute(argument1)
    expect(argument1).to eq(original1)
  end
end