tfwrapper 0.2.0.beta1

data/spec/acceptance/acceptance_spec.rb

@@ -0,0 +1,461 @@
+# frozen_string_literal: true
+
+require_relative 'consulserver'
+require_relative 'acceptance_helpers'
+require 'open3'
+require 'json'
+
+TF_VERSION = '0.9.2'
+
+Diplomat.configure do |config|
+  config.url = 'http://127.0.0.1:8500'
+end
+
+describe 'tfwrapper' do
+  before(:all) do
+    tf_path = File.dirname(HashicorpFetcher.new('terraform', TF_VERSION).fetch)
+    ENV['PATH'] = "#{tf_path}:#{ENV['PATH']}"
+    @server = ConsulServer.new
+  end
+  after(:all) do
+    @server.stop
+  end
+  after(:each) { cleanup_tf }
+  context 'testOne - basic TF with remote state' do
+    before(:all) do
+      @fixturepath = File.absolute_path(
+        File.join(File.dirname(__FILE__), '..', 'fixtures')
+      )
+    end
+    describe 'rake -T' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake -T',
+          chdir: @fixturepath
+        )
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'lists the 5 tasks' do
+        lines = @out_err.split("\n")
+        expect(lines.length).to eq(5)
+      end
+      it 'includes the apply task' do
+        expect(@out_err).to include('rake tf:apply[target]')
+      end
+      it 'includes the destroy task' do
+        expect(@out_err).to include('rake tf:destroy[target]')
+      end
+      it 'includes the init task' do
+        expect(@out_err).to include('rake tf:init')
+      end
+      it 'includes the plan task' do
+        expect(@out_err).to include('rake tf:plan[target]')
+      end
+      it 'includes the write_tf_vars task' do
+        expect(@out_err).to include('rake tf:write_tf_vars')
+      end
+    end
+    describe 'tf:apply' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake tf:apply',
+          chdir: @fixturepath
+        )
+        @varpath = File.join(@fixturepath, 'build.tfvars.json')
+      end
+      after(:all) do
+        File.delete(@varpath) if File.file?(@varpath)
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'uses the correct Terraform version' do
+        expect(@out_err).to include("Terraform v#{TF_VERSION}")
+      end
+      it 'runs apply correctly and succeeds' do
+        expect(@out_err)
+          .to include('terraform_runner command: \'terraform apply -var-file')
+        expect(@out_err).to include('consul_keys.testOne: Creating...')
+        expect(@out_err).to include(
+          'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
+        )
+        expect(@out_err).to include("Outputs:\n\nfoo_variable = bar")
+      end
+      it 'writes the vars file' do
+        expect(File.file?(@varpath)).to be(true)
+        c = File.open(@varpath, 'r').read
+        expect(JSON.parse(c)).to eq({})
+      end
+      it 'sets the consul key' do
+        expect(Diplomat::Kv.get('testOne')).to eq('bar')
+      end
+      it 'writes remote state to consul' do
+        state = JSON.parse(Diplomat::Kv.get('terraform/testOne'))
+        expect(state['version']).to eq(3)
+        expect(state['terraform_version']).to eq(TF_VERSION)
+        expect(state['serial']).to eq(1)
+        expect(state['modules'].length).to eq(1)
+        expect(state['modules'][0]['outputs']['foo_variable']['value'])
+          .to eq('bar')
+        expect(state['modules'][0]['resources'])
+          .to include('consul_keys.testOne')
+        expect(state['modules'][0]['resources'].length).to eq(1)
+      end
+    end
+  end
+  context 'testTwo - TF with vars, remote state and consul env var update' do
+    before(:all) do
+      @fixturepath = File.absolute_path(
+        File.join(File.dirname(__FILE__), '..', 'fixtures', 'testTwo')
+      )
+      ENV['FOO'] = 'fooval'
+    end
+    after(:all) { ENV.delete('FOO') }
+    describe 'rake -T' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake -T',
+          chdir: @fixturepath
+        )
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'lists the 5 tasks' do
+        lines = @out_err.split("\n")
+        expect(lines.length).to eq(5)
+      end
+      it 'includes the apply task' do
+        expect(@out_err).to include('rake tf:apply[target]')
+      end
+      it 'includes the destroy task' do
+        expect(@out_err).to include('rake tf:destroy[target]')
+      end
+      it 'includes the init task' do
+        expect(@out_err).to include('rake tf:init')
+      end
+      it 'includes the plan task' do
+        expect(@out_err).to include('rake tf:plan[target]')
+      end
+      it 'includes the write_tf_vars task' do
+        expect(@out_err).to include('rake tf:write_tf_vars')
+      end
+    end
+    describe 'tf:apply' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake tf:apply',
+          chdir: @fixturepath
+        )
+        @varpath = File.join(@fixturepath, 'build.tfvars.json')
+      end
+      after(:all) do
+        File.delete(@varpath) if File.file?(@varpath)
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'uses the correct Terraform version' do
+        expect(@out_err).to include("Terraform v#{TF_VERSION}")
+      end
+      it 'runs apply correctly and succeeds' do
+        expect(@out_err)
+          .to include('terraform_runner command: \'terraform apply -var-file')
+        expect(@out_err).to include('consul_keys.testTwo: Creating...')
+        expect(@out_err).to include(
+          'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
+        )
+        expect(@out_err).to include(
+          "Outputs:\n\nbar_variable = barval\nfoo_variable = fooval"
+        )
+      end
+      it 'writes the vars file' do
+        expect(File.file?(@varpath)).to be(true)
+        c = File.open(@varpath, 'r').read
+        expect(JSON.parse(c))
+          .to eq('foo' => 'fooval', 'bar' => 'barval')
+      end
+      it 'sets the consul keys' do
+        expect(Diplomat::Kv.get('testTwo/foo')).to eq('fooval')
+        expect(Diplomat::Kv.get('testTwo/bar')).to eq('barval')
+      end
+      it 'writes remote state to consul' do
+        state = JSON.parse(Diplomat::Kv.get('terraform/testTwo'))
+        expect(state['version']).to eq(3)
+        expect(state['terraform_version']).to eq(TF_VERSION)
+        expect(state['serial']).to eq(1)
+        expect(state['modules'].length).to eq(1)
+        expect(state['modules'][0]['outputs']['foo_variable']['value'])
+          .to eq('fooval')
+        expect(state['modules'][0]['outputs']['bar_variable']['value'])
+          .to eq('barval')
+        expect(state['modules'][0]['resources'])
+          .to include('consul_keys.testTwo')
+        expect(state['modules'][0]['resources'].length).to eq(1)
+      end
+    end
+  end
+  context 'testThree - TF with namespaces' do
+    before(:all) do
+      @fixturepath = File.absolute_path(
+        File.join(File.dirname(__FILE__), '..', 'fixtures', 'testThree')
+      )
+      ENV['FOO'] = 'fooval'
+    end
+    after(:all) { ENV.delete('FOO') }
+    describe 'rake -T' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake -T',
+          chdir: @fixturepath
+        )
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'lists the 15 tasks' do
+        lines = @out_err.split("\n")
+        expect(lines.length).to eq(15)
+      end
+      it 'includes the non-namespaced apply task' do
+        expect(@out_err).to include('rake tf:apply[target]')
+      end
+      it 'includes the non-namespaced destroy task' do
+        expect(@out_err).to include('rake tf:destroy[target]')
+      end
+      it 'includes the non-namespaced init task' do
+        expect(@out_err).to include('rake tf:init')
+      end
+      it 'includes the non-namespaced plan task' do
+        expect(@out_err).to include('rake tf:plan[target]')
+      end
+      it 'includes the non-namespaced write_tf_vars task' do
+        expect(@out_err).to include('rake tf:write_tf_vars')
+      end
+      it 'includes the bar-namespaced apply task' do
+        expect(@out_err).to include('rake bar_tf:apply[target]')
+      end
+      it 'includes the bar-namespaced destroy task' do
+        expect(@out_err).to include('rake bar_tf:destroy[target]')
+      end
+      it 'includes the bar-namespaced init task' do
+        expect(@out_err).to include('rake bar_tf:init')
+      end
+      it 'includes the bar-namespaced plan task' do
+        expect(@out_err).to include('rake bar_tf:plan[target]')
+      end
+      it 'includes the bar-namespaced write_tf_vars task' do
+        expect(@out_err).to include('rake bar_tf:write_tf_vars')
+      end
+      it 'includes the baz-namespaced apply task' do
+        expect(@out_err).to include('rake baz_tf:apply[target]')
+      end
+      it 'includes the baz-namespaced destroy task' do
+        expect(@out_err).to include('rake baz_tf:destroy[target]')
+      end
+      it 'includes the baz-namespaced init task' do
+        expect(@out_err).to include('rake baz_tf:init')
+      end
+      it 'includes the baz-namespaced plan task' do
+        expect(@out_err).to include('rake baz_tf:plan[target]')
+      end
+      it 'includes the baz-namespaced write_tf_vars task' do
+        expect(@out_err).to include('rake baz_tf:write_tf_vars')
+      end
+    end
+    describe 'tf:apply' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake tf:apply',
+          chdir: @fixturepath
+        )
+        @varpath = File.join(@fixturepath, 'build.tfvars.json')
+      end
+      after(:all) do
+        File.delete(@varpath) if File.file?(@varpath)
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'uses the correct Terraform version' do
+        expect(@out_err).to include("Terraform v#{TF_VERSION}")
+      end
+      it 'runs apply correctly and succeeds' do
+        expect(@out_err)
+          .to include('terraform_runner command: \'terraform apply -var-file')
+        expect(@out_err).to include('consul_keys.testThreeFoo: Creating...')
+        expect(@out_err).to include(
+          'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
+        )
+        expect(@out_err).to include(
+          "Outputs:\n\nbar_variable = barval\nfoo_variable = fooval"
+        )
+      end
+      it 'writes the vars file' do
+        expect(File.file?(@varpath)).to be(true)
+        c = File.open(@varpath, 'r').read
+        expect(JSON.parse(c))
+          .to eq('foo' => 'fooval', 'bar' => 'barval')
+      end
+      it 'sets the consul keys' do
+        expect(Diplomat::Kv.get('testThreeFoo/foo')).to eq('fooval')
+        expect(Diplomat::Kv.get('testThreeFoo/bar')).to eq('barval')
+      end
+      it 'writes remote state to consul' do
+        state = JSON.parse(Diplomat::Kv.get('terraform/testThreeFoo'))
+        expect(state['version']).to eq(3)
+        expect(state['terraform_version']).to eq(TF_VERSION)
+        expect(state['serial']).to eq(1)
+        expect(state['modules'].length).to eq(1)
+        expect(state['modules'][0]['outputs']['foo_variable']['value'])
+          .to eq('fooval')
+        expect(state['modules'][0]['outputs']['bar_variable']['value'])
+          .to eq('barval')
+        expect(state['modules'][0]['resources'])
+          .to include('consul_keys.testThreeFoo')
+        expect(state['modules'][0]['resources'].length).to eq(1)
+      end
+    end
+    describe 'bar_tf:apply' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake bar_tf:apply',
+          chdir: @fixturepath
+        )
+        @varpath = File.join(@fixturepath, 'bar_build.tfvars.json')
+      end
+      after(:all) do
+        File.delete(@varpath) if File.file?(@varpath)
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'uses the correct Terraform version' do
+        expect(@out_err).to include("Terraform v#{TF_VERSION}")
+      end
+      it 'runs apply correctly and succeeds' do
+        expect(@out_err)
+          .to include('terraform_runner command: \'terraform apply -var-file')
+        expect(@out_err).to include('consul_keys.testThreeBar: Creating...')
+        expect(@out_err).to include(
+          'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
+        )
+        expect(@out_err).to include(
+          "Outputs:\n\nbar_variable = barval\nfoo_variable = fooval"
+        )
+      end
+      it 'writes the vars file' do
+        expect(File.file?(@varpath)).to be(true)
+        c = File.open(@varpath, 'r').read
+        expect(JSON.parse(c))
+          .to eq('foo' => 'fooval', 'bar' => 'barval')
+      end
+      it 'sets the consul keys' do
+        expect(Diplomat::Kv.get('testThreeBar/foo')).to eq('fooval')
+        expect(Diplomat::Kv.get('testThreeBar/bar')).to eq('barval')
+      end
+      it 'writes remote state to consul' do
+        state = JSON.parse(Diplomat::Kv.get('terraform/testThreeBar'))
+        expect(state['version']).to eq(3)
+        expect(state['terraform_version']).to eq(TF_VERSION)
+        expect(state['serial']).to eq(1)
+        expect(state['modules'].length).to eq(1)
+        expect(state['modules'][0]['outputs']['foo_variable']['value'])
+          .to eq('fooval')
+        expect(state['modules'][0]['outputs']['bar_variable']['value'])
+          .to eq('barval')
+        expect(state['modules'][0]['resources'])
+          .to include('consul_keys.testThreeBar')
+        expect(state['modules'][0]['resources'].length).to eq(1)
+      end
+    end
+    describe 'baz_tf:apply' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake baz_tf:apply',
+          chdir: @fixturepath
+        )
+        @varpath = File.join(@fixturepath, 'baz_build.tfvars.json')
+      end
+      after(:all) do
+        File.delete(@varpath) if File.file?(@varpath)
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'uses the correct Terraform version' do
+        expect(@out_err).to include("Terraform v#{TF_VERSION}")
+      end
+      it 'runs apply correctly and succeeds' do
+        expect(@out_err)
+          .to include('terraform_runner command: \'terraform apply -var-file')
+        expect(@out_err).to include('consul_keys.testThreeBaz: Creating...')
+        expect(@out_err).to include(
+          'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
+        )
+        expect(@out_err).to include(
+          "Outputs:\n\nfoo_variable = fooval"
+        )
+      end
+      it 'writes the vars file' do
+        expect(File.file?(@varpath)).to be(true)
+        c = File.open(@varpath, 'r').read
+        expect(JSON.parse(c))
+          .to eq('foo' => 'fooval')
+      end
+      it 'sets the consul keys' do
+        expect(Diplomat::Kv.get('testThreeBaz/foo')).to eq('fooval')
+      end
+      it 'writes remote state to consul' do
+        state = JSON.parse(Diplomat::Kv.get('terraform/testThreeBaz'))
+        expect(state['version']).to eq(3)
+        expect(state['terraform_version']).to eq(TF_VERSION)
+        expect(state['serial']).to eq(1)
+        expect(state['modules'].length).to eq(1)
+        expect(state['modules'][0]['outputs']['foo_variable']['value'])
+          .to eq('fooval')
+        expect(state['modules'][0]['resources'])
+          .to include('consul_keys.testThreeBaz')
+        expect(state['modules'][0]['resources'].length).to eq(1)
+      end
+      it 'writes the environment variables to Consul' do
+        cvars = JSON.parse(Diplomat::Kv.get('vars/testThreeBaz'))
+        expect(cvars).to eq('FOO' => 'fooval')
+      end
+    end
+  end
+end

data/spec/acceptance/consulserver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'acceptance_helpers'
+require 'diplomat'
+require 'retries'
+
+# Run a Consul server process in the background, for acceptance tests
+class ConsulServer
+  def initialize(version = '0.7.5')
+    bin_path = HashicorpFetcher.new('consul', version).fetch
+    @process = Process.spawn(
+      "#{bin_path} agent -server -dev",
+      out: '/dev/null',
+      err: '/dev/null'
+    )
+    Diplomat.configure do |config|
+      config.url = 'http://127.0.0.1:8500'
+    end
+    with_retries(
+      max_tries: 40,
+      base_sleep_seconds: 0.25,
+      max_sleep_seconds: 0.25,
+      rescue: [Faraday::ConnectionFailed, Diplomat::UnknownStatus]
+    ) do
+      Diplomat::Kv.get('/', keys: true)
+    end
+  end
+
+  def stop
+    return if @process.nil?
+    Process.kill('TERM', @process)
+    Process.wait
+  end
+end

data/spec/fixtures/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'tfwrapper/raketasks'
+
+TFWrapper::RakeTasks.install_tasks(
+  '.'
+)

data/spec/fixtures/testOne.tf

@@ -0,0 +1,22 @@
+terraform {
+  required_version = "> 0.9.0"
+  backend "consul" {
+    address = "127.0.0.1:8500"
+    path    = "terraform/testOne"
+  }
+}
+
+provider "consul" {
+  address = "127.0.0.1:8500"
+}
+
+variable "foo" { default = "bar" }
+
+resource "consul_keys" "testOne" {
+  key {
+    path  = "testOne"
+    value = "${var.foo}"
+  }
+}
+
+output "foo_variable" { value = "${var.foo}" }

data/spec/fixtures/testThree/Rakefile

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'tfwrapper/raketasks'
+
+# @option opts [String] :consul_url URL to access Consul at, for the
+#   ``:consul_env_vars_prefix`` option.
+# @option opts [String] :consul_env_vars_prefix if specified and not nil,
+#   write the environment variables used from ``tf_vars_from_env``
+#   and their values to JSON at this path in Consul. This should have
+#   the same naming constraints as ``consul_prefix``.
+
+TFWrapper::RakeTasks.install_tasks(
+  'foo',
+  backend_config: { 'path' => 'terraform/testThreeFoo' },
+  tf_vars_from_env: { 'foo' => 'FOO' },
+  tf_extra_vars: { 'bar' => 'barval' }
+)
+
+TFWrapper::RakeTasks.install_tasks(
+  'bar',
+  namespace_prefix: 'bar',
+  tf_vars_from_env: { 'foo' => 'FOO' },
+  tf_extra_vars: { 'bar' => 'barval' }
+)
+
+TFWrapper::RakeTasks.install_tasks(
+  'baz',
+  namespace_prefix: 'baz',
+  tf_vars_from_env: { 'foo' => 'FOO' },
+  consul_url: 'http://127.0.0.1:8500',
+  consul_env_vars_prefix: 'vars/testThreeBaz'
+)

data/spec/fixtures/testThree/bar/testThreeBar.tf

@@ -0,0 +1,28 @@
+terraform {
+  required_version = "> 0.9.0"
+  backend "consul" {
+    address = "127.0.0.1:8500"
+    path    = "terraform/testThreeBar"
+  }
+}
+
+provider "consul" {
+  address = "127.0.0.1:8500"
+}
+
+variable "foo" {}
+variable "bar" { default = "bar" }
+
+resource "consul_keys" "testThreeBar" {
+  key {
+    path  = "testThreeBar/foo"
+    value = "${var.foo}"
+  }
+  key {
+    path  = "testThreeBar/bar"
+    value = "${var.bar}"
+  }
+}
+
+output "foo_variable" { value = "${var.foo}" }
+output "bar_variable" { value = "${var.bar}" }

data/spec/fixtures/testThree/baz/testThreeBaz.tf

@@ -0,0 +1,22 @@
+terraform {
+  required_version = "> 0.9.0"
+  backend "consul" {
+    address = "127.0.0.1:8500"
+    path    = "terraform/testThreeBaz"
+  }
+}
+
+provider "consul" {
+  address = "127.0.0.1:8500"
+}
+
+variable "foo" {}
+
+resource "consul_keys" "testThreeBaz" {
+  key {
+    path  = "testThreeBaz/foo"
+    value = "${var.foo}"
+  }
+}
+
+output "foo_variable" { value = "${var.foo}" }

data/spec/fixtures/testThree/foo/testThreeFoo.tf

@@ -0,0 +1,27 @@
+terraform {
+  required_version = "> 0.9.0"
+  backend "consul" {
+    address = "127.0.0.1:8500"
+  }
+}
+
+provider "consul" {
+  address = "127.0.0.1:8500"
+}
+
+variable "foo" {}
+variable "bar" { default = "bar" }
+
+resource "consul_keys" "testThreeFoo" {
+  key {
+    path  = "testThreeFoo/foo"
+    value = "${var.foo}"
+  }
+  key {
+    path  = "testThreeFoo/bar"
+    value = "${var.bar}"
+  }
+}
+
+output "foo_variable" { value = "${var.foo}" }
+output "bar_variable" { value = "${var.bar}" }

data/spec/fixtures/testTwo/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'tfwrapper/raketasks'
+
+TFWrapper::RakeTasks.install_tasks(
+  'foo/bar',
+  tf_vars_from_env: { 'foo' => 'FOO' },
+  tf_extra_vars: { 'bar' => 'barval' }
+)

data/spec/fixtures/testTwo/foo/bar/testTwo.tf

@@ -0,0 +1,28 @@
+terraform {
+  required_version = "> 0.9.0"
+  backend "consul" {
+    address = "127.0.0.1:8500"
+    path    = "terraform/testTwo"
+  }
+}
+
+provider "consul" {
+  address = "127.0.0.1:8500"
+}
+
+variable "foo" {}
+variable "bar" { default = "bar" }
+
+resource "consul_keys" "testTwo" {
+  key {
+    path  = "testTwo/foo"
+    value = "${var.foo}"
+  }
+  key {
+    path  = "testTwo/bar"
+    value = "${var.bar}"
+  }
+}
+
+output "foo_variable" { value = "${var.foo}" }
+output "bar_variable" { value = "${var.bar}" }