gene_system 0.3.2 → 0.4.0

data/lib/gene_system/manifest.rb

@@ -18,6 +18,11 @@ module GeneSystem
           File.read(file_path)
         )
 
+        if missing_required?(manifest)
+          raise 'manifest is missing required attributes name, '\
+          'version and/or metadata'
+        end
+
         if incompatible?(manifest)
           raise 'provided manifest is invalid or incompatible with '\
           'this version of gene_system'
@@ -29,6 +34,34 @@ module GeneSystem
         )
       end
 
+      ##
+      # Determines whether there are missing
+      # attributes in given manifest.
+      #
+      # Manifests require name, version and
+      # metadata attributes.
+      #
+      # If these are not present in the given manifest
+      # then this method returns true, indicating
+      # that the manifest does not have all required
+      # attributes and is therefore not valid.
+      #
+      # If they are present, then false will be returned
+      # indicating that the manifest has required
+      # attributes
+      #
+      # @param [GeneSystem::Manifest] manifest
+      #
+      # @return [Boolean]
+      #
+      def missing_required?(manifest)
+        return true unless manifest['name']
+        return true unless manifest['version']
+        return true unless manifest['metadata']
+
+        false
+      end
+
       ##
       # Incompatible returns true if the current manifest is not compatible
       # with this version of GeneSystem.
@@ -57,6 +90,15 @@ module GeneSystem
       @steps = GeneSystem::Step.load_steps(@data.steps)
     end
 
+    ##
+    # Manifest name and version getter
+    #
+    # @return [String]
+    #
+    def name_and_version
+      "#{name} v#{version}"
+    end
+
     ##
     # Manifest name getter
     #
@@ -110,7 +152,7 @@ module GeneSystem
     #
     # By default a all steps will be returned.
     #
-    # @example
+    # Example:
     # query = ->(step) { step.tags.include?("foo") }
     # manifest.steps(query)
     #
@@ -123,5 +165,20 @@ module GeneSystem
         query.call(step)
       end
     end
+
+    ##
+    # Returns manifest information and variables
+    #
+    # @return [Hashie::Mash]
+    #
+    def variables
+      Hashie::Mash.new(
+        'manifest' => {
+          'name' => name,
+          'version' => version,
+          'metadata' => metadata
+        }
+      )
+    end
   end
 end

data/lib/gene_system/platform.rb

@@ -1,5 +1,6 @@
 require 'os'
 require 'ruby-handlebars'
+require 'cgi'
 
 module GeneSystem
   # Platform is a class to handle command execution on host system

data/lib/gene_system/version.rb

@@ -1,3 +1,3 @@
 module GeneSystem
-  VERSION = '0.3.2'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/manifest.json

@@ -0,0 +1,59 @@
+{
+  "name": "manifest.json",
+  "version": "0.0.1",
+  "metadata": {
+    "gene_system": {
+      "version": "0.3.2"
+    }
+  },
+  "steps": [
+    {
+      "name": "greet user",
+      "exe": {
+        "install": {
+          "prompts": [
+            {
+              "prompt": "Please enter your name",
+              "var": "name"
+            }
+          ],
+          "cmd": [
+            "echo hello '{{name}}'"
+          ]
+        },
+        "remove": {
+          "prompts": [
+            {
+              "prompt": "Please enter your name",
+              "var": "name"
+            }
+          ],
+          "cmd": [
+            "echo 'goodbye {{name}}'"
+          ]
+        }
+      },
+      "tags": "example step"
+    },
+    {
+      "name": "print version",
+      "exe": {
+        "install": {
+          "cmd": [
+            "echo '{{manifest.name}}'",
+            "echo '{{manifest.version}}'",
+            "echo '{{manifest.metadata.gene_system.version}}'"
+          ]
+        },
+        "remove": {
+          "cmd": [
+            "echo '{{manifest.name}}'",
+            "echo '{{manifest.version}}'",
+            "echo '{{manifest.metadata.gene_system.version}}'"
+          ]
+        }
+      },
+      "tags": "example front matter access"
+    }
+  ]
+}

data/spec/gene_system/cli_spec.rb

@@ -1,83 +1,105 @@
 require 'spec_helper'
 
 RSpec.describe GeneSystem::CLI do
-  let(:logger) { double(Logger) }
-  let(:err_logger) { double(Logger) }
-  let(:message) { 'All work and no play makes Jack a dull boy' }
+  subject { described_class.new }
 
-  before do
-    allow(described_class).to receive(:exit).and_return(double)
-  end
+  describe '#version' do
+    let(:version) { double(GeneSystem::Commands::PrintVersion) }
+    let(:options) { double }
 
-  describe '.logger' do
-    let(:out) { double(STDOUT) }
     before do
-      allow(Logger).to receive(:new).and_return(logger)
-      allow(logger).to receive(:formatter=)
-      subject.logger(out)
-    end
+      allow(subject).to receive(:options).and_return(options)
+      allow(GeneSystem::Commands::PrintVersion)
+        .to receive(:new)
+        .and_return(version)
 
-    it 'creates a new logger to STDOUT' do
-      expect(Logger).to have_received(:new).with(out)
+      allow(version).to receive(:run)
+      subject.version
     end
-  end
 
-  describe '.print_message' do
-    let(:logger) { double(Logger) }
-
-    before do
-      allow(described_class).to receive(:logger).and_return(logger)
-      allow(logger).to receive(:info)
-      described_class.print_message(message)
+    it 'creates a new version command' do
+      expect(GeneSystem::Commands::PrintVersion)
+        .to have_received(:new)
+        .with(options)
     end
 
-    it 'prints message to stdout' do
-      expect(logger).to have_received(:info).with(message)
+    it 'calls run' do
+      expect(version).to have_received(:run)
     end
   end
 
-  describe '.print_warning' do
-    let(:logger) { double(Logger) }
+  describe '#new' do
+    let(:new) { double(GeneSystem::Commands::CreateManifest) }
+    let(:options) { double }
 
     before do
-      allow(described_class).to receive(:logger).and_return(logger)
-      allow(logger).to receive(:warn)
-      described_class.print_warning(message)
+      allow(subject).to receive(:options).and_return(options)
+      allow(GeneSystem::Commands::CreateManifest)
+        .to receive(:new)
+        .and_return(new)
+
+      allow(new).to receive(:run)
+      subject.new
     end
 
-    it 'prints message to stdout' do
-      expect(logger).to have_received(:warn).with(message)
+    it 'creates a new new command' do
+      expect(GeneSystem::Commands::CreateManifest)
+        .to have_received(:new)
+        .with(options)
+    end
+
+    it 'calls run' do
+      expect(new).to have_received(:run)
     end
   end
 
-  describe '.print_error' do
-    let(:logger) { double(Logger) }
+  describe '#install' do
+    let(:install) { double(GeneSystem::Commands::InstallManifest) }
+    let(:options) { double }
 
     before do
-      allow(described_class).to receive(:logger).and_return(logger)
-      allow(logger).to receive(:error)
-      described_class.print_error(message)
+      allow(subject).to receive(:options).and_return(options)
+      allow(GeneSystem::Commands::InstallManifest)
+        .to receive(:new)
+        .and_return(install)
+
+      allow(install).to receive(:run)
+      subject.install
     end
 
-    it 'prints message to stderr' do
-      expect(logger).to have_received(:error).with(message)
+    it 'creates a new install command' do
+      expect(GeneSystem::Commands::InstallManifest)
+        .to have_received(:new)
+        .with(options)
+    end
+
+    it 'calls run' do
+      expect(install).to have_received(:run)
     end
   end
 
-  describe '.print_message_and_exit' do
-    let(:exit_code) { 2 }
+  describe '#remove' do
+    let(:remove) { double(GeneSystem::Commands::RemoveManifest) }
+    let(:options) { double }
 
     before do
-      allow(described_class).to receive(:print_message)
-      described_class.print_message_and_exit(message, exit_code)
+      allow(subject).to receive(:options).and_return(options)
+      allow(GeneSystem::Commands::RemoveManifest)
+        .to receive(:new)
+        .and_return(remove)
+
+      allow(remove).to receive(:run)
+      subject.remove
     end
 
-    it 'prints message' do
-      expect(described_class).to have_received(:print_message).with(message)
+    it 'creates a new remove command' do
+      expect(GeneSystem::Commands::RemoveManifest)
+        .to have_received(:new)
+        .with(options)
     end
 
-    it 'exits with set status' do
-      expect(described_class).to have_received(:exit).with(exit_code)
+    it 'calls run' do
+      expect(remove).to have_received(:run)
     end
   end
 end

data/spec/gene_system/commands/create_manifest_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+RSpec.describe GeneSystem::Commands::CreateManifest do
+  let(:name_opt) { 'manifest.jsonnet' }
+  let(:output_opt) { '/path/to/output' }
+
+  let(:options) do
+    Hashie::Mash.new(
+      name: name_opt,
+      out: output_opt
+    )
+  end
+
+  subject { described_class.new(options) }
+
+  describe '#run' do
+    let(:prompt) { double }
+    let(:prompt_response) { nil }
+
+    let(:is_dir) { true }
+
+    before do
+      subject.instance_variable_set(:@prompt, prompt)
+
+      allow(File).to receive(:directory?).and_return(is_dir)
+      allow(subject).to receive(:puts)
+
+      allow(prompt).to receive(:ask)
+        .and_return(prompt_response)
+
+      allow(GeneSystem::Generators)
+        .to receive(:render_empty_manifest)
+    end
+
+    context 'when name and output prompt is provided' do
+      before { subject.run }
+
+      it 'does not ask for any input' do
+        expect(prompt).not_to have_received(:ask)
+      end
+
+      it 'renders empty manifest' do
+        expect(GeneSystem::Generators)
+          .to have_received(:render_empty_manifest)
+          .with(name_opt, output_opt)
+      end
+
+      it 'reports success' do
+        expect(subject)
+          .to have_received(:puts)
+          .with('✔ Manifest successfully created in /path/to/output')
+      end
+    end
+
+    context 'when only name is provided' do
+      let(:output_opt) { nil }
+      let(:prompt_response) { '/path/to/given/output' }
+
+      before { subject.run }
+
+      it 'prompts for output location' do
+        expect(prompt).to have_received(:ask)
+          .with(
+            'Please specify output location',
+            default: Dir.pwd
+          )
+      end
+
+      it 'renders empty manifest' do
+        expect(GeneSystem::Generators)
+          .to have_received(:render_empty_manifest)
+          .with(name_opt, prompt_response)
+      end
+
+      it 'reports success' do
+        expect(subject)
+          .to have_received(:puts)
+          .with('✔ Manifest successfully created in /path/to/given/output')
+      end
+    end
+
+    context 'when only output is provided' do
+      let(:name_opt) { nil }
+      let(:prompt_response) { 'abc.json' }
+
+      before { subject.run }
+
+      it 'prompts for manifest name' do
+        expect(prompt).to have_received(:ask)
+          .with(
+            'Please enter the name of the manifest',
+            default: described_class::DEFAULT_MANIFEST_NAME
+          )
+      end
+
+      it 'renders empty manifest' do
+        expect(GeneSystem::Generators)
+          .to have_received(:render_empty_manifest)
+          .with(prompt_response, output_opt)
+      end
+
+      it 'reports success' do
+        expect(subject)
+          .to have_received(:puts)
+          .with('✔ Manifest successfully created in /path/to/output')
+      end
+    end
+
+    context 'when the output location is not a directory' do
+      let(:is_dir) { false }
+
+      it 'raises runtime error' do
+        expect do
+          subject.run
+        end.to raise_error('output location must be a folder')
+      end
+    end
+  end
+end

data/spec/gene_system/commands/install_manifest_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+
+RSpec.describe GeneSystem::Commands::InstallManifest do
+  let(:options) { Hashie::Mash.new }
+  let(:prompt) { double(TTY::Prompt) }
+  let(:version) { '1.0.0' }
+  let(:execute_command_result) { 0 }
+  let(:manifest_name) { 'some manifest' }
+
+  subject { described_class.new(options) }
+
+  before do
+    subject.instance_variable_set(:@prompt, prompt)
+  end
+
+  describe '#run' do
+    let(:platform) { double(GeneSystem::Platform) }
+
+    let(:manifest) do
+      double(
+        GeneSystem::Manifest,
+        name: manifest_name,
+        name_and_version: "#{manifest_name} v#{version}"
+      )
+    end
+
+    let(:skip_command) { 'false' }
+    let(:prompts) { [prompt_definition, prompt_definition] }
+    let(:prompt_definition) do
+      {
+        "prompt": 'Please enter your name',
+        "var": 'name'
+      }
+    end
+    let(:cmd) { 'echo {{name}}' }
+    let(:cmds) do
+      [
+        cmd
+      ]
+    end
+
+    let(:step_definition) do
+      {
+        "name": 'some step',
+        "exe": {
+          "install": {
+            "skip": skip_command,
+            "prompts": prompts,
+            "cmd": cmds
+          }
+        }
+      }
+    end
+
+    let(:step) do
+      GeneSystem::Step.new(step_definition)
+    end
+
+    before do
+      allow(GeneSystem::Manifest)
+        .to receive(:new_from_file)
+        .and_return(manifest)
+
+      allow(GeneSystem::Platform)
+        .to receive(:new)
+        .and_return(platform)
+
+      allow(manifest)
+        .to receive(:steps)
+        .and_return([step, step])
+
+      allow(manifest)
+        .to receive(:version)
+        .and_return(version)
+
+      allow(manifest)
+        .to receive(:variables)
+        .and_return({})
+
+      allow(platform)
+        .to receive(:execute_commands)
+
+      allow(platform)
+        .to receive(:execute_command)
+        .and_return(execute_command_result)
+
+      allow(prompt).to receive(:ask).and_return(prompt_response)
+      allow(subject).to receive(:puts)
+    end
+
+    context 'when manifest path is provided' do
+      let(:manifest_path) { 'provided/path/to/manifest.json' }
+      let(:execute_command_result) { 1 }
+      let(:prompt_response) { 'Jon' }
+      let(:options) do
+        Hashie::Mash.new(
+          manifest: manifest_path
+        )
+      end
+
+      before do
+        subject.run
+      end
+
+      it 'loads manifest from expected file' do
+        expect(GeneSystem::Manifest)
+          .to have_received(:new_from_file)
+          .with(manifest_path)
+      end
+
+      it 'prints install message' do
+        expect(subject)
+          .to have_received(:puts)
+          .with("INSTALL #{manifest_name} v#{version}")
+      end
+
+      describe 'skip steps' do
+        context 'when there is a skip command defined' do
+          it 'checks whether it should skip any steps' do
+            expect(platform)
+              .to have_received(:execute_command)
+              .with(skip_command).twice
+          end
+        end
+
+        context 'when there is no skip command defined' do
+          let(:step_definition) do
+            {
+              "name": 'some step',
+              "exe": {
+                "install": {
+                  "skip": nil,
+                  "cmd": []
+                }
+              }
+            }
+          end
+
+          it 'does not try to run nil command' do
+            expect(platform)
+              .not_to have_received(:execute_command)
+          end
+        end
+
+        context 'when the skip command returns non zero' do
+          let(:execute_command_result) { 1 }
+          let(:prompts) { [] }
+
+          it 'does not execute step' do
+            expect(platform)
+              .not_to have_received(:execute_command)
+              .with(cmd)
+          end
+        end
+      end
+
+      describe 'prompting user for input' do
+        context 'when there are no prompts' do
+          let(:prompts) { [] }
+
+          it 'does not ask user for input' do
+            expect(prompt)
+              .not_to have_received(:ask)
+          end
+        end
+
+        context 'when there are prompts' do
+          it 'asks user for input' do
+            expect(prompt)
+              .to have_received(:ask)
+              .with('Please enter your name').exactly(4).times
+          end
+        end
+      end
+
+      it 'executes step commands' do
+        expect(platform)
+          .to have_received(:execute_commands)
+          .with(cmds, 'name' => prompt_response).twice
+      end
+
+      it 'prints success message' do
+        expect(subject)
+          .to have_received(:puts)
+          .with("✔ Manifest #{manifest_name} v#{version} successfully installed")
+      end
+    end
+
+    context 'when the manifest name is not provided' do
+      let(:prompt_response) { '/path/to/manifest.json' }
+
+      before do
+        allow(prompt)
+          .to receive(:ask)
+          .and_return(prompt_response)
+
+        subject.run
+      end
+
+      describe 'prompting user for manifest path' do
+        it 'prompts user for manifest path' do
+          expect(prompt)
+            .to have_received(:ask)
+            .with(
+              'Please enter the path to the configuration manifest',
+              default: 'manifest.json'
+            )
+        end
+      end
+
+      describe 'skipping steps' do
+        context 'when there is a skip command defined' do
+          it 'checks whether it should skip any steps' do
+            expect(platform)
+              .to have_received(:execute_command)
+              .with(skip_command).twice
+          end
+        end
+
+        context 'when there is no skip command defined' do
+          let(:step_definition) do
+            {
+              "name": 'some step',
+              "exe": {
+                "install": {
+                  "skip": nil,
+                  "cmd": []
+                }
+              }
+            }
+          end
+
+          it 'does not try to run nil command' do
+            expect(platform)
+              .not_to have_received(:execute_command)
+          end
+        end
+
+        context 'when the skip command returns non zero' do
+          let(:execute_command_result) { 1 }
+          let(:prompts) { [] }
+
+          it 'does not execute step' do
+            expect(platform)
+              .not_to have_received(:execute_command)
+              .with(cmd)
+          end
+        end
+      end
+
+      it 'prints success message' do
+        expect(subject)
+          .to have_received(:puts)
+          .with("✔ Manifest #{manifest_name} v#{version} successfully installed")
+      end
+    end
+  end
+end