packer-config 0.0.3

data/spec/packer/postprocessors/docker_import_spec.rb

@@ -0,0 +1,27 @@
+# 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::DockerImport do
+  let(:postprocessor) do
+    Packer::PostProcessor.get_postprocessor(Packer::PostProcessor::DOCKER_IMPORT)
+  end
+
+  describe '#initialize' do
+    it 'has a type of shell' do
+      expect(postprocessor.data['type']).to eq(Packer::PostProcessor::DOCKER_IMPORT)
+    end
+  end
+end

data/spec/packer/postprocessors/docker_push_spec.rb

@@ -0,0 +1,27 @@
+# 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::DockerPush do
+  let(:postprocessor) do
+    Packer::PostProcessor.get_postprocessor(Packer::PostProcessor::DOCKER_PUSH)
+  end
+
+  describe '#initialize' do
+    it 'has a type of shell' do
+      expect(postprocessor.data['type']).to eq(Packer::PostProcessor::DOCKER_PUSH)
+    end
+  end
+end

data/spec/packer/postprocessors/vagrant_spec.rb

@@ -0,0 +1,27 @@
+# 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::Vagrant do
+  let(:postprocessor) do
+    Packer::PostProcessor.get_postprocessor(Packer::PostProcessor::VAGRANT)
+  end
+
+  describe '#initialize' do
+    it 'has a type of shell' do
+      expect(postprocessor.data['type']).to eq(Packer::PostProcessor::VAGRANT)
+    end
+  end
+end

data/spec/packer/provisioner_spec.rb

@@ -0,0 +1,78 @@
+# 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::Provisioner do
+  PROVISIONER_TYPE = 'shell'
+
+  let(:provisioner) do
+    Packer::Provisioner.new
+  end
+
+  let(:overrides) do
+    {
+      "key1" => "value1",
+      "key2" => "value2"
+    }
+  end
+
+  describe '.get_provisioner' do
+    it 'returns a provisioner' do
+      expect(Packer::Provisioner.get_provisioner(PROVISIONER_TYPE)).to be_a_kind_of(Packer::Provisioner)
+    end
+
+    it 'raises an error when the provisioner type is not recognized' do
+      expect { Packer::Provisioner.get_provisioner('unknown-type') }.to raise_error
+    end
+  end
+
+  describe '#only' do
+    it 'adds an only exception' do
+      provisioner.only('thing1')
+      expect(provisioner.data['only']).to eq(%w[thing1])
+      provisioner.only('thing2')
+      expect(provisioner.data['only']).to eq(%w[thing1 thing2])
+    end
+  end
+
+  describe '#except' do
+    it 'adds an execpt exception' do
+      provisioner.except('thing3')
+      expect(provisioner.data['except']).to eq(%w[thing3])
+      provisioner.except('thing4')
+      expect(provisioner.data['except']).to eq(%w[thing3 thing4])
+    end
+  end
+
+  describe '#pause_before' do
+    it 'adds a pause time' do
+      provisioner.pause_before(10)
+      expect(provisioner.data['pause_before']).to eq("10")
+      provisioner.pause_before("10s")
+      expect(provisioner.data['pause_before']).to eq("10s")
+    end
+  end
+
+  describe '#override' do
+    it 'adds a hash overridef override values to a list of overrides' do
+      provisioner.override('build', overrides)
+      expect(provisioner.data['override']['build']).to eq(overrides)
+    end
+
+    it 'raises a TypeError when the overrides are not a hash' do
+      expect { provisioner.override('build', 10) }.to raise_error
+    end
+  end
+end

data/spec/packer/provisioners/file_spec.rb

@@ -0,0 +1,63 @@
+# 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::Provisioner::File do
+  let(:provisioner) do
+    Packer::Provisioner.get_provisioner('file')
+  end
+
+  let(:some_string) do
+    'some string'
+  end
+
+  let(:some_array_of_ints) do
+    [1, 2, 3]
+  end
+
+  describe '#initialize' do
+    it 'has a type of file' do
+      expect(provisioner.data['type']).to eq('file')
+    end
+  end
+
+  describe '#source' do
+    it 'accepts a string' do
+      provisioner.source(some_string)
+      expect(provisioner.data['source']).to eq(some_string)
+      provisioner.data.delete('source')
+    end
+
+    it 'converts any argument passed to a string' do
+      provisioner.source(some_array_of_ints)
+      expect(provisioner.data['source']).to eq(some_array_of_ints.to_s)
+      provisioner.data.delete('source')
+    end
+  end
+
+  describe '#destination' do
+    it 'accepts a string' do
+      provisioner.destination(some_string)
+      expect(provisioner.data['destination']).to eq(some_string)
+      provisioner.data.delete('destination')
+    end
+
+    it 'converts any argument passed to a string' do
+      provisioner.destination(some_array_of_ints)
+      expect(provisioner.data['destination']).to eq(some_array_of_ints.to_s)
+      provisioner.data.delete('destination')
+    end
+  end
+end

data/spec/packer/provisioners/shell_spec.rb

@@ -0,0 +1,116 @@
+# 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::Provisioner::Shell do
+  let(:provisioner) do
+    Packer::Provisioner.get_provisioner('shell')
+  end
+
+  let(:some_string) do
+    'some string'
+  end
+
+  let(:some_array_of_strings) do
+    %w[commmand1 command2]
+  end
+
+  let(:some_array_of_ints) do
+    [1, 2, 3]
+  end
+
+  describe '#initialize' do
+    it 'has a type of shell' do
+      expect(provisioner.data['type']).to eq('shell')
+    end
+  end
+
+  describe '#inline' do
+    it 'accepts an array of commands' do
+      provisioner.inline(some_array_of_strings)
+      expect(provisioner.data['inline']).to eq(some_array_of_strings)
+      provisioner.data.delete('inline')
+    end
+
+    it 'converts all commands to strings' do
+      provisioner.inline(some_array_of_ints)
+      expect(provisioner.data['inline']).to eq(some_array_of_ints.map{ |c| c.to_s })
+      provisioner.data.delete('inline')
+    end
+
+    it 'raises an error if the commands argument cannot be made an Array' do
+      expect { provisioner.inline(some_string) }.to raise_error
+    end
+
+    it 'raises an error if #script or #scripts method was already called' do
+      provisioner.data['script'] = 1
+      expect { provisioner.inline(some_array_of_strings) }.to raise_error
+      provisioner.data.delete('script')
+      provisioner.data['scripts'] = 1
+      expect { provisioner.inline(some_array_of_strings) }.to raise_error
+      provisioner.data.delete('scripts')
+    end
+  end
+
+  describe '#script' do
+    it 'accepts a string' do
+      provisioner.script(some_string)
+      expect(provisioner.data['script']).to eq(some_string)
+      provisioner.data.delete('script')
+    end
+
+    it 'converts any argument passed to a string' do
+      provisioner.script(some_array_of_ints)
+      expect(provisioner.data['script']).to eq(some_array_of_ints.to_s)
+      provisioner.data.delete('script')
+    end
+
+    it 'raises an error if #inline or #scripts method was already called' do
+      provisioner.data['inline'] = 1
+      expect { provisioner.script(some_string) }.to raise_error
+      provisioner.data.delete('inline')
+      provisioner.data['scripts'] = 1
+      expect { provisioner.script(some_string) }.to raise_error
+      provisioner.data.delete('scripts')
+    end
+  end
+
+  describe '#scripts' do
+    it 'accepts an array of commands' do
+      provisioner.scripts(some_array_of_strings)
+      expect(provisioner.data['scripts']).to eq(some_array_of_strings)
+      provisioner.data.delete('scripts')
+    end
+
+    it 'converts all commands to strings' do
+      provisioner.scripts(some_array_of_ints)
+      expect(provisioner.data['scripts']).to eq(some_array_of_ints.map{ |c| c.to_s })
+      provisioner.data.delete('scripts')
+    end
+
+    it 'raises an error if the commands argument cannot be made an Array' do
+      expect { provisioner.scripts(some_string) }.to raise_error
+    end
+
+    it 'raises an error if #inline or #script method was already called' do
+      provisioner.data['script'] = 1
+      expect { provisioner.scripts(some_array_of_strings) }.to raise_error
+      provisioner.data.delete('scripts')
+      provisioner.data['inline'] = 1
+      expect { provisioner.scripts(some_array_of_strings) }.to raise_error
+      provisioner.data.delete('scripts')
+    end
+  end
+end

data/spec/packer_config_spec.rb

@@ -0,0 +1,197 @@
+# 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'
+require 'fakefs/spec_helpers'
+
+RSpec.describe Packer::Config do
+  let(:config_file) { 'config.json'}
+  let(:packer) { Packer::Config.new(config_file) }
+  let(:builder_type) { Packer::Builder::VIRTUALBOX_ISO }
+  let(:provisioner_type) { Packer::Provisioner::FILE }
+  let(:postprocessor_type) { Packer::PostProcessor::VAGRANT }
+  let(:json_representation) do
+    '{"variables":{"foo":"bar"},"builders":[{"type":"virtualbox-iso"}],"provisioners":[{"type":"file"}],"post-processors":[{"type":"vagrant"}]}'
+  end
+
+  describe '#initialize' do
+    it 'returns an instance' do
+      expect(packer).to be_a_kind_of(Packer::Config)
+    end
+  end
+
+  describe "#validate" do
+    it 'returns true for a valid instance' do
+      expect(packer.builders).to receive(:length).and_return(1)
+      open3 = class_double("Open3").as_stubbed_const(:transfer_nested_constants => true)
+      expect(open3).to receive(:capture3).and_return(['output', 'error', 0])
+      FakeFS do
+        expect(packer.validate).to be_truthy
+      end
+    end
+
+    it 'raises an error for an invalid instance' do
+      expect(packer.builders).to receive(:length).and_return(0)
+      FakeFS do
+        expect { packer.validate }.to raise_error
+      end
+    end
+  end
+
+  describe '#dump' do
+    it 'dumps a JSON-formatted configuration' do
+      packer.add_builder builder_type
+      packer.add_provisioner provisioner_type
+      packer.add_postprocessor postprocessor_type
+      packer.add_variable 'foo', 'bar'
+      expect(packer.dump).to eq(json_representation)
+    end
+
+    it 'raises an error if the format is not recognized' do
+      expect { packer.dump 'invalid-format' }.to raise_error
+    end
+  end
+
+  describe '#write' do
+    it 'writes a JSON-formatted configuration file to disk' do
+      packer.add_builder builder_type
+      packer.add_provisioner provisioner_type
+      packer.add_postprocessor postprocessor_type
+      packer.add_variable 'foo', 'bar'
+      FakeFS do
+        packer.write
+        expect(File.read(config_file)).to eq(json_representation)
+      end
+    end
+
+    it 'raises an error if the format is not recognized' do
+      FakeFS do
+        expect { packer.dump 'invalid-format' }.to raise_error
+      end
+    end
+  end
+
+  describe "#build" do
+    it 'returns successfully if the build command returns a successful exit code' do
+      expect(packer).to receive(:validate).and_return(true)
+      expect(packer).to receive(:write).and_return(true)
+      open3 = class_double("Open3").as_stubbed_const(:transfer_nested_constants => true)
+      expect(open3).to receive(:capture3).and_return(['output', 'error', 0])
+      FakeFS do
+        expect(packer.build).to be_truthy
+      end
+    end
+
+    it 'raises an error if the data is not valid' do
+      expect(packer).to receive(:validate).and_raise(Packer::DataObject::DataValidationError)
+      FakeFS do
+        expect { packer.build }.to raise_error
+      end
+    end
+
+    it 'raises an error if the config cannot be written to disk' do
+      expect(packer).to receive(:validate).and_return(true)
+      expect(packer).to receive(:write).and_raise(StandardError)
+      expect { packer.build }.to raise_error
+    end
+
+    it 'raises an error if the build command returns an unsuccessful exit code' do
+      expect(packer).to receive(:validate).and_return(true)
+      expect(packer).to receive(:write).and_return(true)
+      open3 = class_double("Open3").as_stubbed_const(:transfer_nested_constants => true)
+      expect(open3).to receive(:capture3).and_return(['output', 'error', 1])
+      FakeFS do
+        expect { packer.build }.to raise_error
+      end
+    end
+  end
+
+  describe "#add_builder" do
+    it 'returns a builder for a valid type' do
+      expect(packer.add_builder builder_type).to be_a_kind_of(Packer::Builder)
+      expect(packer.builders.length).to eq(1)
+      packer.builders = []
+    end
+
+    it 'raises an error for an invalid type' do
+      expect { packer.add_builder 'invalid' }.to raise_error
+      expect(packer.builders.length).to eq(0)
+    end
+  end
+
+  describe "#add_provisioner" do
+    it 'returns a provisioner for a valid type' do
+      expect(packer.add_provisioner provisioner_type).to be_a_kind_of(Packer::Provisioner)
+      expect(packer.provisioners.length).to eq(1)
+      packer.provisioners = []
+    end
+
+    it 'raises an error for an invalid type' do
+      expect { packer.add_provisioner 'invalid' }.to raise_error
+      expect(packer.provisioners.length).to eq(0)
+    end
+  end
+
+  describe "#add_postprocessor" do
+    it 'returns a post-processor for a valid type' do
+      expect(packer.add_postprocessor postprocessor_type).to be_a_kind_of(Packer::PostProcessor)
+      expect(packer.postprocessors.length).to eq(1)
+      packer.postprocessors = []
+    end
+
+    it 'raises an error for an invalid type' do
+      expect { packer.add_postprocessor 'invalid' }.to raise_error
+      expect(packer.postprocessors.length).to eq(0)
+    end
+  end
+
+  describe '#add_variable' do
+    it 'adds a new variable key/value pair' do
+      expect(packer.variables).to eq({})
+      packer.add_variable('key1', 'value1')
+      expect(packer.variables).to eq({'key1' => 'value1'})
+      packer.add_variable('key2', 'value2')
+      expect(packer.variables).to eq({'key1' => 'value1', 'key2' => 'value2'})
+      packer.data['variables'] = {}
+    end
+  end
+
+  describe '#variable' do
+    it 'creates a packer reference to a variable in the configuration' do
+      expect(packer.variables).to eq({})
+      packer.add_variable('key1', 'value1')
+      expect(packer.variable 'key1').to eq('{{user `key1`}}')
+      packer.data['variables'] = {}
+    end
+
+    it 'raises an error when the variable has not been defined in the configuration' do
+      expect(packer.variables).to eq({})
+      expect { packer.variable 'key1' }.to raise_error
+      packer.data['variables'] = {}
+    end
+  end
+
+  describe '#envvar' do
+    it 'creates a packer reference to an environment variable' do
+      expect(packer.envvar.TEST).to eq('{{env `TEST`}}')
+    end
+  end
+
+  describe '#macro' do
+    it 'creates a packer macro reference for any method call' do
+      expect(packer.macro.var).to eq('{{ .Var }}')
+    end
+  end
+
+end