cheffish 4.0.0 → 4.1.0

data/spec/integration/chef_client_spec.rb

@@ -1,50 +1,50 @@
-require 'support/spec_support'
-require 'cheffish/rspec/chef_run_support'
-require 'support/key_support'
-require 'chef/resource/chef_client'
+require "support/spec_support"
+require "cheffish/rspec/chef_run_support"
+require "support/key_support"
+require "chef/resource/chef_client"
 
-repo_path = Dir.mktmpdir('chef_repo')
+repo_path = Dir.mktmpdir("chef_repo")
 
 describe Chef::Resource::ChefClient do
   extend Cheffish::RSpec::ChefRunSupport
 
-  when_the_chef_12_server 'is in multi-org mode' do
-    organization 'foo'
+  when_the_chef_12_server "is in multi-org mode" do
+    organization "foo"
 
     before :each do
-      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, '/organizations/foo').to_s
+      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, "/organizations/foo").to_s
     end
 
-    context 'and is empty' do
-      context 'and we have a private key with a path' do
+    context "and is empty" do
+      context "and we have a private key with a path" do
         with_converge do
           private_key "#{repo_path}/blah.pem"
         end
 
         context 'and we run a recipe that creates client "blah"' do
-          it 'the client gets created' do
-            expect_recipe {
-              chef_client 'blah' do
+          it "the client gets created" do
+            expect_recipe do
+              chef_client "blah" do
                 source_key_path "#{repo_path}/blah.pem"
               end
-            }.to have_updated 'chef_client[blah]', :create
-            client = get('clients/blah')
-            expect(client['name']).to eq('blah')
-            key, format = Cheffish::KeyFormatter.decode(client['public_key'])
+            end.to have_updated "chef_client[blah]", :create
+            client = get("clients/blah")
+            expect(client["name"]).to eq("blah")
+            key, format = Cheffish::KeyFormatter.decode(client["public_key"])
             expect(key).to be_public_key_for("#{repo_path}/blah.pem")
           end
         end
 
         context 'and we run a recipe that creates client "blah" with output_key_path' do
           with_converge do
-            chef_client 'blah' do
+            chef_client "blah" do
               source_key_path "#{repo_path}/blah.pem"
               output_key_path "#{repo_path}/blah.pub"
             end
           end
 
-          it 'the output public key gets created' do
-            expect(IO.read("#{repo_path}/blah.pub")).to start_with('ssh-rsa ')
+          it "the output public key gets created" do
+            expect(IO.read("#{repo_path}/blah.pub")).to start_with("ssh-rsa ")
             expect("#{repo_path}/blah.pub").to be_public_key_for("#{repo_path}/blah.pem")
           end
         end
@@ -56,21 +56,21 @@ describe Chef::Resource::ChefClient do
         end
 
         with_converge do
-          private_key 'blah'
+          private_key "blah"
         end
 
         context "and a chef_client 'foobar' resource with source_key_path 'blah'" do
-          it 'the client is accessible via the given private key' do
-            expect_recipe {
-              chef_client 'foobar' do
-                source_key_path 'blah'
+          it "the client is accessible via the given private key" do
+            expect_recipe do
+              chef_client "foobar" do
+                source_key_path "blah"
               end
-            }.to have_updated 'chef_client[foobar]', :create
-            client = get('clients/foobar')
-            key, format = Cheffish::KeyFormatter.decode(client['public_key'])
+            end.to have_updated "chef_client[foobar]", :create
+            client = get("clients/foobar")
+            key, format = Cheffish::KeyFormatter.decode(client["public_key"])
             expect(key).to be_public_key_for("#{repo_path}/blah.pem")
 
-            private_key = Cheffish::KeyFormatter.decode(Cheffish.get_private_key('blah'))
+            private_key = Cheffish::KeyFormatter.decode(Cheffish.get_private_key("blah"))
             expect(key).to be_public_key_for(private_key)
           end
         end
@@ -78,23 +78,23 @@ describe Chef::Resource::ChefClient do
     end
   end
 
-  when_the_chef_server 'is in OSC mode' do
-    context 'and is empty' do
-      context 'and we have a private key with a path' do
+  when_the_chef_server "is in OSC mode" do
+    context "and is empty" do
+      context "and we have a private key with a path" do
         with_converge do
           private_key "#{repo_path}/blah.pem"
         end
 
         context 'and we run a recipe that creates client "blah"' do
-          it 'the client gets created' do
-            expect_recipe {
-              chef_client 'blah' do
+          it "the client gets created" do
+            expect_recipe do
+              chef_client "blah" do
                 source_key_path "#{repo_path}/blah.pem"
               end
-            }.to have_updated 'chef_client[blah]', :create
-            client = get('clients/blah')
-            expect(client['name']).to eq('blah')
-            key, format = Cheffish::KeyFormatter.decode(client['public_key'])
+            end.to have_updated "chef_client[blah]", :create
+            client = get("clients/blah")
+            expect(client["name"]).to eq("blah")
+            key, format = Cheffish::KeyFormatter.decode(client["public_key"])
             expect(key).to be_public_key_for("#{repo_path}/blah.pem")
           end
         end

data/spec/integration/chef_container_spec.rb

@@ -1,30 +1,30 @@
-require 'support/spec_support'
-require 'cheffish/rspec/chef_run_support'
+require "support/spec_support"
+require "cheffish/rspec/chef_run_support"
 
 describe Chef::Resource::ChefContainer do
   extend Cheffish::RSpec::ChefRunSupport
 
-  when_the_chef_12_server 'is in multi-org mode' do
-    organization 'foo'
+  when_the_chef_12_server "is in multi-org mode" do
+    organization "foo"
 
     before :each do
-      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, '/organizations/foo').to_s
+      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, "/organizations/foo").to_s
     end
 
     it 'Converging chef_container "x" creates the container' do
-      expect_recipe {
-        chef_container 'x'
-      }.to have_updated('chef_container[x]', :create)
-      expect { get('containers/x') }.not_to raise_error
+      expect_recipe do
+        chef_container "x"
+      end.to have_updated("chef_container[x]", :create)
+      expect { get("containers/x") }.not_to raise_error
     end
 
-    context 'and already has a container named x' do
-      container 'x', {}
+    context "and already has a container named x" do
+      container "x", {}
 
       it 'Converging chef_container "x" changes nothing' do
-        expect_recipe {
-          chef_container 'x'
-        }.not_to have_updated('chef_container[x]', :create)
+        expect_recipe do
+          chef_container "x"
+        end.not_to have_updated("chef_container[x]", :create)
       end
     end
   end

data/spec/integration/chef_data_bag_item_spec.rb

@@ -1,23 +1,23 @@
-require 'support/spec_support'
-require 'cheffish/rspec/chef_run_support'
+require "support/spec_support"
+require "cheffish/rspec/chef_run_support"
 
 describe Chef::Resource::ChefDataBagItem do
   extend Cheffish::RSpec::ChefRunSupport
 
-  when_the_chef_12_server 'foo' do
-    organization 'foo'
+  when_the_chef_12_server "foo" do
+    organization "foo"
 
     before :each do
-      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, '/organizations/foo').to_s
+      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, "/organizations/foo").to_s
     end
 
     context 'when data bag "bag" exists' do
-      with_converge { chef_data_bag 'bag' }
+      with_converge { chef_data_bag "bag" }
 
       it 'runs a recipe that creates a chef_data_bag_item "bag/item"' do
-        expect_recipe {
-          chef_data_bag_item 'bag/item'
-        }.to have_updated 'chef_data_bag_item[bag/item]', :create
+        expect_recipe do
+          chef_data_bag_item "bag/item"
+        end.to have_updated "chef_data_bag_item[bag/item]", :create
         # expect(get('data_bags/bag')['name']).to eq('bag')
         # expect(get('data_bags/bag/item')['id']).to eq('item')
       end

data/spec/integration/chef_group_spec.rb

@@ -1,305 +1,305 @@
-require 'support/spec_support'
-require 'cheffish/rspec/chef_run_support'
+require "support/spec_support"
+require "cheffish/rspec/chef_run_support"
 
 describe Chef::Resource::ChefGroup do
   extend Cheffish::RSpec::ChefRunSupport
 
-  when_the_chef_12_server 'is in multi-org mode' do
-    organization 'foo'
+  when_the_chef_12_server "is in multi-org mode" do
+    organization "foo"
 
     before :each do
-      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, '/organizations/foo').to_s
+      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, "/organizations/foo").to_s
     end
 
-    context 'and is empty' do
-      group 'g', {}
-      user 'u', {}
-      client 'c', {}
+    context "and is empty" do
+      group "g", {}
+      user "u", {}
+      client "c", {}
 
       it 'Converging chef_group "x" creates the group with no members' do
-        expect_recipe {
-          chef_group 'x'
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => [],
-          'groups'  => [],
-          'users'   => [],
-          'clients' => []
+        expect_recipe do
+          chef_group "x"
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => [],
+          "groups"  => [],
+          "users"   => [],
+          "clients" => [],
         })
       end
 
       it 'chef_group "x" action :delete does nothing' do
-        expect_recipe {
-          chef_group 'x' do
+        expect_recipe do
+          chef_group "x" do
             action :delete
           end
-        }.to not_have_updated('chef_group[x]', :delete).and not_have_updated('chef_group[x]', :create)
-        expect { get('groups/x') }.to raise_error(Net::HTTPServerException)
+        end.to not_have_updated("chef_group[x]", :delete).and not_have_updated("chef_group[x]", :create)
+        expect { get("groups/x") }.to raise_error(Net::HTTPServerException)
       end
 
       it 'Converging chef_group "x" creates the group with the given members' do
-        expect_recipe {
-          chef_group 'x' do
-            groups 'g'
-            users 'u'
-            clients 'c'
+        expect_recipe do
+          chef_group "x" do
+            groups "g"
+            users "u"
+            clients "c"
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => %w(c u),
-          'groups'  => %w(g),
-          'users'   => %w(u),
-          'clients' => %w(c)
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => %w{c u},
+          "groups"  => %w{g},
+          "users"   => %w{u},
+          "clients" => %w{c},
         })
       end
     end
 
-    context 'and has a group named x' do
-      group 'g', {}
-      group 'g2', {}
-      group 'g3', {}
-      group 'g4', {}
-      user 'u', {}
-      user 'u2', {}
-      user 'u3', {}
-      user 'u4', {}
-      client 'c', {}
-      client 'c2', {}
-      client 'c3', {}
-      client 'c4', {}
+    context "and has a group named x" do
+      group "g", {}
+      group "g2", {}
+      group "g3", {}
+      group "g4", {}
+      user "u", {}
+      user "u2", {}
+      user "u3", {}
+      user "u4", {}
+      client "c", {}
+      client "c2", {}
+      client "c3", {}
+      client "c4", {}
 
-      group 'x', {
-        'users' => %w(u u2),
-        'clients' => %w(c c2),
-        'groups' => %w(g g2)
+      group "x", {
+        "users" => %w{u u2},
+        "clients" => %w{c c2},
+        "groups" => %w{g g2},
       }
 
       it 'Converging chef_group "x" changes nothing' do
-        expect_recipe {
-          chef_group 'x'
-        }.not_to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => %w(c c2 u u2),
-          'groups'  => %w(g g2),
-          'users'   => %w(u u2),
-          'clients' => %w(c c2)
+        expect_recipe do
+          chef_group "x"
+        end.not_to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => %w{c c2 u u2},
+          "groups"  => %w{g g2},
+          "users"   => %w{u u2},
+          "clients" => %w{c c2},
         })
       end
 
       it 'chef_group "x" action :delete deletes the group' do
-        expect_recipe {
-          chef_group 'x' do
+        expect_recipe do
+          chef_group "x" do
             action :delete
           end
-        }.to have_updated('chef_group[x]', :delete)
-        expect { get('groups/x') }.to raise_error(Net::HTTPServerException)
+        end.to have_updated("chef_group[x]", :delete)
+        expect { get("groups/x") }.to raise_error(Net::HTTPServerException)
       end
 
       it 'Converging chef_group "x" with existing users changes nothing' do
-        expect_recipe {
-          chef_group 'x' do
-            users 'u'
-            clients 'c'
-            groups 'g'
+        expect_recipe do
+          chef_group "x" do
+            users "u"
+            clients "c"
+            groups "g"
           end
-        }.not_to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => %w(c c2 u u2),
-          'groups'  => %w(g g2),
-          'users'   => %w(u u2),
-          'clients' => %w(c c2)
+        end.not_to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => %w{c c2 u u2},
+          "groups"  => %w{g g2},
+          "users"   => %w{u u2},
+          "clients" => %w{c c2},
         })
       end
 
       it 'Converging chef_group "x" adds new users' do
-        expect_recipe {
-          chef_group 'x' do
-            users 'u3'
-            clients 'c3'
-            groups 'g3'
+        expect_recipe do
+          chef_group "x" do
+            users "u3"
+            clients "c3"
+            groups "g3"
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => %w(c c2 c3 u u2 u3),
-          'groups'  => %w(g g2 g3),
-          'users'   => %w(u u2 u3),
-          'clients' => %w(c c2 c3)
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => %w{c c2 c3 u u2 u3},
+          "groups"  => %w{g g2 g3},
+          "users"   => %w{u u2 u3},
+          "clients" => %w{c c2 c3},
         })
       end
 
       it 'Converging chef_group "x" with multiple users adds new users' do
-        expect_recipe {
-          chef_group 'x' do
-            users 'u3', 'u4'
-            clients 'c3', 'c4'
-            groups 'g3', 'g4'
+        expect_recipe do
+          chef_group "x" do
+            users "u3", "u4"
+            clients "c3", "c4"
+            groups "g3", "g4"
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => %w(c c2 c3 c4 u u2 u3 u4),
-          'groups'  => %w(g g2 g3 g4),
-          'users'   => %w(u u2 u3 u4),
-          'clients' => %w(c c2 c3 c4)
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => %w{c c2 c3 c4 u u2 u3 u4},
+          "groups"  => %w{g g2 g3 g4},
+          "users"   => %w{u u2 u3 u4},
+          "clients" => %w{c c2 c3 c4},
         })
       end
 
       it 'Converging chef_group "x" with multiple users in an array adds new users' do
-        expect_recipe {
-          chef_group 'x' do
-            users [ 'u3', 'u4' ]
-            clients [ 'c3', 'c4' ]
-            groups [ 'g3', 'g4' ]
+        expect_recipe do
+          chef_group "x" do
+            users %w{u3 u4}
+            clients %w{c3 c4}
+            groups %w{g3 g4}
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => %w(c c2 c3 c4 u u2 u3 u4),
-          'groups'  => %w(g g2 g3 g4),
-          'users'   => %w(u u2 u3 u4),
-          'clients' => %w(c c2 c3 c4)
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => %w{c c2 c3 c4 u u2 u3 u4},
+          "groups"  => %w{g g2 g3 g4},
+          "users"   => %w{u u2 u3 u4},
+          "clients" => %w{c c2 c3 c4},
         })
       end
 
       it 'Converging chef_group "x" with multiple users declarations adds new users' do
-        expect_recipe {
-          chef_group 'x' do
-            users 'u3'
-            users 'u4'
-            clients 'c3'
-            clients 'c4'
-            groups 'g3'
-            groups 'g4'
+        expect_recipe do
+          chef_group "x" do
+            users "u3"
+            users "u4"
+            clients "c3"
+            clients "c4"
+            groups "g3"
+            groups "g4"
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => %w(c c2 c3 c4 u u2 u3 u4),
-          'groups'  => %w(g g2 g3 g4),
-          'users'   => %w(u u2 u3 u4),
-          'clients' => %w(c c2 c3 c4)
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => %w{c c2 c3 c4 u u2 u3 u4},
+          "groups"  => %w{g g2 g3 g4},
+          "users"   => %w{u u2 u3 u4},
+          "clients" => %w{c c2 c3 c4},
         })
       end
 
       it 'Converging chef_group "x" removes desired users' do
-        expect_recipe {
-          chef_group 'x' do
-            remove_users 'u2'
-            remove_clients 'c2'
-            remove_groups 'g2'
+        expect_recipe do
+          chef_group "x" do
+            remove_users "u2"
+            remove_clients "c2"
+            remove_groups "g2"
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => %w(c u),
-          'groups'  => %w(g),
-          'users'   => %w(u),
-          'clients' => %w(c)
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => %w{c u},
+          "groups"  => %w{g},
+          "users"   => %w{u},
+          "clients" => %w{c},
         })
       end
 
       it 'Converging chef_group "x" with multiple users removes desired users' do
-        expect_recipe {
-          chef_group 'x' do
-            remove_users 'u', 'u2'
-            remove_clients 'c', 'c2'
-            remove_groups 'g', 'g2'
+        expect_recipe do
+          chef_group "x" do
+            remove_users "u", "u2"
+            remove_clients "c", "c2"
+            remove_groups "g", "g2"
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => [],
-          'groups'  => [],
-          'users'   => [],
-          'clients' => []
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => [],
+          "groups"  => [],
+          "users"   => [],
+          "clients" => [],
         })
       end
 
       it 'Converging chef_group "x" with multiple users in an array removes desired users' do
-        expect_recipe {
-          chef_group 'x' do
-            remove_users [ 'u', 'u2' ]
-            remove_clients [ 'c', 'c2' ]
-            remove_groups [ 'g', 'g2' ]
+        expect_recipe do
+          chef_group "x" do
+            remove_users %w{u u2}
+            remove_clients %w{c c2}
+            remove_groups %w{g g2}
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => [],
-          'groups'  => [],
-          'users'   => [],
-          'clients' => []
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => [],
+          "groups"  => [],
+          "users"   => [],
+          "clients" => [],
         })
       end
 
       it 'Converging chef_group "x" with multiple remove_ declarations removes desired users' do
-        expect_recipe {
-          chef_group 'x' do
-            remove_users 'u'
-            remove_users 'u2'
-            remove_clients 'c'
-            remove_clients 'c2'
-            remove_groups 'g'
-            remove_groups 'g2'
+        expect_recipe do
+          chef_group "x" do
+            remove_users "u"
+            remove_users "u2"
+            remove_clients "c"
+            remove_clients "c2"
+            remove_groups "g"
+            remove_groups "g2"
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => [],
-          'groups'  => [],
-          'users'   => [],
-          'clients' => []
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => [],
+          "groups"  => [],
+          "users"   => [],
+          "clients" => [],
         })
       end
 
       it 'Converging chef_group "x" adds and removes desired users' do
-        expect_recipe {
-          chef_group 'x' do
-            users 'u3'
-            clients 'c3'
-            groups 'g3'
-            remove_users 'u'
-            remove_clients 'c'
-            remove_groups 'g'
+        expect_recipe do
+          chef_group "x" do
+            users "u3"
+            clients "c3"
+            groups "g3"
+            remove_users "u"
+            remove_clients "c"
+            remove_groups "g"
           end
-        }.to have_updated('chef_group[x]', :create)
-        expect(get('groups/x')).to eq({
-          'name' => 'x',
-          'groupname' => 'x',
-          'orgname' => 'foo',
-          'actors'  => %w(c2 c3 u2 u3),
-          'groups'  => %w(g2 g3),
-          'users'   => %w(u2 u3),
-          'clients' => %w(c2 c3)
+        end.to have_updated("chef_group[x]", :create)
+        expect(get("groups/x")).to eq({
+          "name" => "x",
+          "groupname" => "x",
+          "orgname" => "foo",
+          "actors"  => %w{c2 c3 u2 u3},
+          "groups"  => %w{g2 g3},
+          "users"   => %w{u2 u3},
+          "clients" => %w{c2 c3},
         })
       end
     end