packer-config 0.0.3

data/spec/packer/builders/docker_spec.rb

@@ -0,0 +1,25 @@
+# Encoding: utf-8
+# Copyright 2014 Ian Chesal
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'spec_helper'
+
+RSpec.describe Packer::Builder::Docker do
+  let(:builder) { Packer::Builder.get_builder(Packer::Builder::DOCKER) }
+
+  describe '#initialize' do
+    it 'has a type of docker' do
+      expect(builder.data['type']).to eq(Packer::Builder::DOCKER)
+    end
+  end
+end

data/spec/packer/builders/virtualbox_spec.rb

@@ -0,0 +1,44 @@
+# Encoding: utf-8
+# Copyright 2014 Ian Chesal
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'spec_helper'
+
+RSpec.describe Packer::Builder::VirtualBoxISO do
+  let(:builder) { Packer::Builder.get_builder(Packer::Builder::VIRTUALBOX_ISO) }
+  let(:in_commands_strings)  { [["command1", "1"], ["command2", "2"]] }
+  let(:in_commands_mixed)    { [["command1",  1 ], ["command2",  2 ]] }
+  let(:out_commands_strings) { [["command1", "1"], ["command2", "2"]] }
+
+  describe '#initialize' do
+    it 'has a type of virtualbox-iso' do
+      expect(builder.data['type']).to eq(Packer::Builder::VIRTUALBOX_ISO)
+    end
+  end
+
+  describe '#vboxmanage' do
+    it 'builds an array of arrays of strings' do
+      builder.vboxmanage(in_commands_mixed)
+      expect( builder.data['vboxmanage'] ).to eq(out_commands_strings)
+      builder.data.delete('vboxmanage')
+    end
+  end
+
+  describe '#vboxmanage_post' do
+    it 'builds an array of arrays of strings' do
+      builder.vboxmanage_post(in_commands_mixed)
+      expect( builder.data['vboxmanage_post'] ).to eq(out_commands_strings)
+      builder.data.delete('vboxmanage_post')
+    end
+  end
+end

data/spec/packer/dataobject_spec.rb

@@ -0,0 +1,239 @@
+# Encoding: utf-8
+# Copyright 2014 Ian Chesal
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'spec_helper'
+
+RSpec.describe Packer::DataObject do
+  let(:dataobject)            { Packer::DataObject.new }
+  let(:some_string)           { 'some string' }
+  let(:keys)                  { %w[key1 key2] }
+  let(:some_array_of_strings) { %w[value1 value2 value3] }
+  let(:some_array_of_ints)    { [1, 2, 3] }
+  let(:some_hash_of_mixed)    { { 'a' =>  1,  'b' =>  2  } }
+  let(:some_hash_of_strings)  { { 'a' => '1', 'b' => '2' } }
+  let(:in_commands_strings)   { [["command1", "1"], ["command2", "2"]] }
+  let(:in_commands_mixed)     { [["command1",  1 ], ["command2",  2 ]] }
+  let(:out_commands_strings)  { [["command1", "1"], ["command2", "2"]] }
+
+  describe "#initialize" do
+    it 'has a data hash' do
+      expect(dataobject.data).to eq({})
+    end
+  end
+
+  describe '#add_required' do
+    it 'tracks required settings' do
+      dataobject.add_required('a', 'b')
+      dataobject.add_required(['c', 'd'])
+      expect(dataobject.required).to eq(['a', 'b', ['c', 'd']])
+    end
+  end
+
+  describe '#validate' do
+    it 'returns true when all required settings are present' do
+      dataobject.add_required('key')
+      dataobject.__add_string('key', 'value')
+      expect(dataobject.validate).to be_truthy
+      dataobject.data = []
+      dataobject.required = []
+    end
+
+    it 'raises an error when a required setting is missing' do
+      dataobject.add_required('key')
+      expect { dataobject.validate }.to raise_error
+      dataobject.data = []
+      dataobject.required = []
+    end
+
+    it 'returns true when exactly one setting from an exclusive set is preset' do
+      dataobject.add_required(['key1', 'key2'])
+      dataobject.__add_string('key1', 'value')
+      expect(dataobject.validate).to be_truthy
+      dataobject.data = []
+      dataobject.required = []
+    end
+
+    it 'raises an error when no settings from an exclusive set are present' do
+      dataobject.add_required(['key1', 'key2'])
+      expect { dataobject.validate }.to raise_error
+      dataobject.data = []
+      dataobject.required = []
+    end
+
+    it 'raises an error when more than one setting from an exclusive set is present' do
+      dataobject.add_required(['key1', 'key2'])
+      dataobject.__add_string('key1', 'value')
+      dataobject.__add_string('key2', 'value')
+      expect { dataobject.validate }.to raise_error
+      dataobject.data = []
+      dataobject.required = []
+    end
+
+    it 'returns true when there are no required settings to validate' do
+      expect(dataobject.validate).to be_truthy
+    end
+  end
+
+  describe '#deep_copy' do
+    it 'retuns a full copy of the data structure' do
+      dataobject.__add_string('key', 'foo')
+      copy = dataobject.deep_copy
+      expect(copy).to eq(dataobject.data)
+      expect(copy).not_to be(dataobject.data)
+      copy['key'] << 'bar'
+      expect(copy).not_to eq(dataobject.data)
+      dataobject.data.delete('key')
+    end
+  end
+
+  describe "#__exclusive_key_error" do
+    it 'returns true when the key is exclusive' do
+      dataobject.data[keys[0]] = 'value'
+      expect(dataobject.__exclusive_key_error(keys[0], keys[1..-1])).to be_truthy
+      dataobject.data.delete(keys[0])
+    end
+
+    it 'raises an error when the key is not exclusive' do
+      dataobject.data[keys[0]] = 'value'
+      dataobject.data[keys[1]] = 'value'
+      expect { dataobject.__exclusive_key_error(keys[0], keys[1..-1]) }.to raise_error
+      dataobject.data.delete(keys)
+    end
+  end
+
+  describe '#__add_array_of_strings' do
+    it 'assigns an array of strings to key' do
+      dataobject.__add_array_of_strings('key', some_array_of_strings)
+      expect(dataobject.data['key']).to eq(some_array_of_strings)
+      dataobject.data.delete('key')
+    end
+
+    it 'converts an array of non-strings to strings and assigns them to key' do
+      dataobject.__add_array_of_strings('key', some_array_of_ints)
+      expect(dataobject.data['key']).to eq(some_array_of_ints.map{ |c| c.to_s })
+      dataobject.data.delete('key')
+    end
+
+    it 'raises an error if the values cannot be turned in to an Array' do
+      expect { dataobject.__add_array_of_strings('key', 'some string') }.to raise_error
+    end
+  end
+
+  describe "#__add_array_of_array_of_strings" do
+    it 'assigns an array of array of strings to key' do
+      dataobject.__add_array_of_array_of_strings('key', in_commands_strings)
+      expect(dataobject.data['key']).to eq(out_commands_strings)
+      dataobject.data.delete('key')
+    end
+
+    it 'converts non-strings to strings in the sub-arrays during assignment to key' do
+      dataobject.__add_array_of_array_of_strings('key', in_commands_mixed)
+      expect(dataobject.data['key']).to eq(out_commands_strings)
+      dataobject.data.delete('key')
+    end
+
+    it 'raises an error if the values argument is not an array' do
+      expect { dataobject.__add_array_of_array_of_strings('key', 'some string') }.to raise_error
+    end
+
+    it 'raises an error if any element in the values argument is not an array' do
+      expect { dataobject.__add_array_of_array_of_strings('key', [['legal'], 'illegal']) }.to raise_error
+    end
+  end
+
+  describe '#__add_string' do
+    it 'accepts a string' do
+      dataobject.__add_string('key', some_string)
+      expect(dataobject.data['key']).to eq(some_string)
+      dataobject.data.delete('key')
+    end
+
+    it 'converts any argument passed to a string' do
+      dataobject.__add_string('key', some_array_of_ints)
+      expect(dataobject.data['key']).to eq(some_array_of_ints.to_s)
+      dataobject.data.delete('key')
+    end
+  end
+
+  describe '#__add_integer' do
+    it 'accepts anything that can be converted to an integer with #to_i' do
+      dataobject.__add_integer(keys[0], 1)
+      dataobject.__add_integer(keys[1], "2")
+      expect(dataobject.data[keys[0]]).to eq(1)
+      expect(dataobject.data[keys[1]]).to eq(2)
+      dataobject.data.delete(keys)
+    end
+
+    it 'raises an error if the value cannot be converted to an integer with #to_i' do
+      expect { dataobject.__add_integer('key', StandardError.new("not convertable")) }.to raise_error
+    end
+  end
+
+  describe '#__add_boolean' do
+    it 'accepts any truthy value and converts it to true' do
+      dataobject.__add_boolean('key', some_string)
+      expect(dataobject.data['key']).to be_truthy
+      dataobject.data.delete('key')
+    end
+
+    it 'accepts any non-truthy value and converts it to false' do
+      dataobject.__add_boolean('key', false)
+      expect(dataobject.data['key']).to be_falsey
+      dataobject.data.delete('key')
+    end
+  end
+
+  describe '#__add_hash' do
+    it 'assigns a hash to a key' do
+      dataobject.__add_hash('key', some_hash_of_strings)
+      expect(dataobject.data['key']).to eq(some_hash_of_strings)
+      dataobject.data.delete('key')
+    end
+
+    it 'converts a hash of non-strings to strings and assigns them to key' do
+      dataobject.__add_hash('key', some_hash_of_mixed)
+      expect(dataobject.data['key']).to eq(some_hash_of_strings)
+      dataobject.data.delete('key')
+    end
+
+    it 'raises an error if the values argument is not a Hash' do
+      expect { dataobject.__add_hash('key', 'some string') }.to raise_error
+    end
+  end
+
+  describe '#__add_array_of_hashes' do
+    it 'assigns an array of hashes to a key' do
+      array = [some_hash_of_strings, some_hash_of_strings]
+      dataobject.__add_array_of_hashes('key', array)
+      expect(dataobject.data['key']).to eq(array)
+      dataobject.data.delete('key')
+    end
+
+    it 'converts non-strings in the hashes to strings during assignment to key' do
+      array = [some_hash_of_mixed, some_hash_of_mixed]
+      dataobject.__add_array_of_hashes('key', array)
+      expect(dataobject.data['key']).to eq([some_hash_of_strings, some_hash_of_strings])
+      dataobject.data.delete('key')
+    end
+
+    it 'raises an error if the values argument is not an array' do
+      expect { dataobject.__add_array_of_hashes('key', 'some string') }.to raise_error
+    end
+
+    it 'raises an error if any element in the values argument is not a Hash' do
+      expect { dataobject.__add_array_of_hashes('key', [some_hash_of_strings, 'illegal']) }.to raise_error
+    end
+  end
+
+end

data/spec/packer/envvar_spec.rb

@@ -0,0 +1,38 @@
+# Encoding: utf-8
+# Copyright 2014 Ian Chesal
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'spec_helper'
+
+RSpec.describe Packer::EnvVar do
+  let(:envvar) do
+    Packer::EnvVar.new
+  end
+
+  it 'returns a packer.io envvar string for any method' do
+    expect(envvar.FOO).to eq("{{env `FOO`}}")
+    expect(envvar.BAR).to eq("{{env `BAR`}}")
+    expect(envvar.MOO).to eq("{{env `MOO`}}")
+  end
+
+  it 'never changes the capitalization of the env var' do
+    expect(envvar.foo).to eq("{{env `foo`}}")
+    expect(envvar.Foo).to eq("{{env `Foo`}}")
+    expect(envvar.fOo).to eq("{{env `fOo`}}")
+  end
+
+  it 'responds to anything' do
+    expect(envvar.respond_to? 'anything').to       be_truthy
+    expect(envvar.respond_to? 'anything_else').to  be_truthy
+  end
+end

data/spec/packer/macro_spec.rb

@@ -0,0 +1,38 @@
+# Encoding: utf-8
+# Copyright 2014 Ian Chesal
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'spec_helper'
+
+RSpec.describe Packer::Macro do
+  let(:macro) do
+    Packer::Macro.new
+  end
+
+  it 'returns a packer.io macro string for any method' do
+    expect(macro.Foo).to eq("{{ .Foo }}")
+    expect(macro.Bar).to eq("{{ .Bar }}")
+    expect(macro.Moo).to eq("{{ .Moo }}")
+  end
+
+  it 'always capitalizes the first letter in the macro' do
+    expect(macro.foo).to eq("{{ .Foo }}")
+    expect(macro.Foo).to eq("{{ .Foo }}")
+    expect(macro.fOo).to eq("{{ .FOo }}")
+  end
+
+  it 'responds to anything' do
+    expect(macro.respond_to? 'anything').to       be_truthy
+    expect(macro.respond_to? 'anything_else').to  be_truthy
+  end
+end

data/spec/packer/postprocessor_spec.rb

@@ -0,0 +1,72 @@
+# Encoding: utf-8
+# Copyright 2014 Ian Chesal
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+require 'spec_helper'
+
+RSpec.describe Packer::PostProcessor do
+  POSTPROCESSOR_TYPE = 'vagrant'
+
+  let(:postprocessor) do
+    Packer::PostProcessor.new
+  end
+
+  let(:overrides) do
+    {
+      "key1" => "value1",
+      "key2" => "value2"
+    }
+  end
+
+  describe '.get_postprocessor' do
+    it 'returns a post-processor' do
+      expect(Packer::PostProcessor.get_postprocessor(POSTPROCESSOR_TYPE)).to be_a_kind_of(Packer::PostProcessor)
+    end
+
+    it 'raises an error when the post-processor type is not recognized' do
+      expect { Packer::PostProcessor.get_postprocessor('unknown-type') }.to raise_error
+    end
+  end
+
+  describe '#only' do
+    it 'adds an only exception' do
+      postprocessor.only('thing1')
+      expect(postprocessor.data['only']).to eq(%w[thing1])
+      postprocessor.only('thing2')
+      expect(postprocessor.data['only']).to eq(%w[thing1 thing2])
+    end
+  end
+
+  describe '#except' do
+    it 'adds an execpt exception' do
+      postprocessor.except('thing3')
+      expect(postprocessor.data['except']).to eq(%w[thing3])
+      postprocessor.except('thing4')
+      expect(postprocessor.data['except']).to eq(%w[thing3 thing4])
+    end
+  end
+
+  describe '#keep_input_artifact' do
+    it 'accepts any truthy value and converts it to true' do
+      postprocessor.keep_input_artifact('this is true')
+      expect(postprocessor.data['keep_input_artifact']).to be_truthy
+      postprocessor.data.delete('keep_input_artifact')
+    end
+
+    it 'accepts any non-truthy value and converts it to false' do
+      postprocessor.keep_input_artifact(false)
+      expect(postprocessor.data['keep_input_artifact']).to be_falsey
+      postprocessor.data.delete('keep_input_artifact')
+    end
+  end
+end