gene_system 0.3.2

data/spec/gene_system/cli_spec.rb

@@ -0,0 +1,83 @@
+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' }
+
+  before do
+    allow(described_class).to receive(:exit).and_return(double)
+  end
+
+  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
+
+    it 'creates a new logger to STDOUT' do
+      expect(Logger).to have_received(:new).with(out)
+    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)
+    end
+
+    it 'prints message to stdout' do
+      expect(logger).to have_received(:info).with(message)
+    end
+  end
+
+  describe '.print_warning' do
+    let(:logger) { double(Logger) }
+
+    before do
+      allow(described_class).to receive(:logger).and_return(logger)
+      allow(logger).to receive(:warn)
+      described_class.print_warning(message)
+    end
+
+    it 'prints message to stdout' do
+      expect(logger).to have_received(:warn).with(message)
+    end
+  end
+
+  describe '.print_error' do
+    let(:logger) { double(Logger) }
+
+    before do
+      allow(described_class).to receive(:logger).and_return(logger)
+      allow(logger).to receive(:error)
+      described_class.print_error(message)
+    end
+
+    it 'prints message to stderr' do
+      expect(logger).to have_received(:error).with(message)
+    end
+  end
+
+  describe '.print_message_and_exit' do
+    let(:exit_code) { 2 }
+
+    before do
+      allow(described_class).to receive(:print_message)
+      described_class.print_message_and_exit(message, exit_code)
+    end
+
+    it 'prints message' do
+      expect(described_class).to have_received(:print_message).with(message)
+    end
+
+    it 'exits with set status' do
+      expect(described_class).to have_received(:exit).with(exit_code)
+    end
+  end
+end

data/spec/gene_system/generators_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+RSpec.describe GeneSystem::Generators do
+  describe '::TEMPLATE_MANIFEST' do
+    let(:name) { 'my_dev_setup' }
+
+    before do
+      @manifest = Hashie::Mash.new(
+        described_class::TEMPLATE_MANIFEST.call(name)
+      )
+    end
+
+    it 'has expected name' do
+      expect(@manifest.name).to eq name
+    end
+
+    it 'has expected version' do
+      expect(@manifest.version).to eq '0.0.1'
+    end
+
+    it 'has gene system metadata' do
+      expect(@manifest.metadata.gene_system).not_to be nil
+    end
+
+    it 'renders app version into gene system metadata' do
+      expect(@manifest.metadata.gene_system.version)
+        .to eq GeneSystem::VERSION
+    end
+
+    it 'has default step' do
+      expect(@manifest.steps.first).to eq described_class::DEFAULT_STEP
+    end
+  end
+
+  describe '.render_empty_manifest' do
+    let(:name) { 'new_dev_setup' }
+    let(:path) { 'path/to/manifests' }
+
+    let(:manifest_path) { File.join(path, "#{name}.json") }
+    let(:manifest_file) { double }
+
+    let(:manifest) { 'manifest' }
+
+    before do
+      allow(File).to receive(:open)
+        .with(manifest_path, 'w')
+        .and_yield(manifest_file)
+      allow(manifest_file).to receive(:write)
+
+      allow(described_class::TEMPLATE_MANIFEST)
+        .to receive(:call).and_return(manifest)
+
+      described_class.render_empty_manifest(
+        name,
+        path
+      )
+    end
+
+    it 'renders blank manifest' do
+      expect(manifest_file)
+        .to have_received(:write)
+        .with("\"#{manifest}\"")
+    end
+  end
+end

data/spec/gene_system/manifest_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+
+RSpec.describe GeneSystem::Manifest do
+  describe '.new_from_file' do
+    let(:file_path) { 'path/to/manifest' }
+    let(:exist) { true }
+    let(:manifest_name) { 'manifest name' }
+
+    let(:gene_system_meta) do
+      {
+        'gene_system' => {
+          'version' => GeneSystem::VERSION
+        }
+      }
+    end
+
+    let(:version) { '0.0.1' }
+    let(:platform) { 'macos' }
+    let(:content) do
+      {
+        'name' => manifest_name,
+        'version' => version,
+        'platform' => platform,
+        'metadata' => gene_system_meta,
+        'steps' => []
+      }.to_json
+    end
+
+    before do
+      allow(File).to receive(:exist?).and_return(exist)
+      allow(File).to receive(:read).and_return(content)
+      allow(Jsonnet).to receive(:evaluate).and_call_original
+    end
+
+    context 'when file exists' do
+      before do
+        @parsed = described_class.new_from_file(file_path)
+      end
+
+      it 'reads file' do
+        expect(File).to have_received(:read).with(file_path)
+      end
+
+      it 'parses json' do
+        expect(Jsonnet).to have_received(:evaluate).with(content)
+      end
+
+      it 'returns manifest' do
+        expect(@parsed).to be_a GeneSystem::Manifest
+      end
+
+      it 'has name' do
+        expect(@parsed.name).to eq manifest_name
+      end
+
+      it 'has version' do
+        expect(@parsed.version).to eq version
+      end
+
+      it 'has platform' do
+        expect(@parsed.platform).to eq platform
+      end
+
+      it 'has metadata' do
+        expect(@parsed.metadata).to eq gene_system_meta
+      end
+    end
+
+    context 'when manifest is from a later version of gene_system' do
+      let(:gene_system_meta) do
+        {
+          'gene_system' => {
+            'version' => '999.999.999'
+          }
+        }
+      end
+
+      it 'raises incompatibility error' do
+        expect do
+          described_class.new_from_file(file_path)
+        end.to raise_error 'provided manifest is invalid or incompatible with '\
+        'this version of gene_system'
+      end
+    end
+
+    context 'when gene_system metadata is missing' do
+      let(:gene_system_meta) { {} }
+      it 'raises incompatibility error' do
+        expect do
+          described_class.new_from_file(file_path)
+        end.to raise_error 'provided manifest is invalid or incompatible with '\
+        'this version of gene_system'
+      end
+    end
+  end
+
+  describe '#name' do
+    let(:path) { 'path/to/manifest.json' }
+
+    let(:data) do
+      {
+        'name' => 'test_manifest',
+        'version' => '0.1.0',
+        'steps' => []
+      }
+    end
+
+    before do
+      @manifest = described_class.new(path, data)
+    end
+
+    it 'returns name' do
+      expect(@manifest.name).to eq 'test_manifest'
+    end
+  end
+
+  describe '#version' do
+    let(:path) { 'path/to/manifest.json' }
+
+    let(:data) do
+      {
+        'name' => 'test_manifest',
+        'version' => '0.1.0',
+        'steps' => []
+      }
+    end
+
+    before do
+      @manifest = described_class.new(path, data)
+    end
+
+    it 'returns version' do
+      expect(@manifest.version).to eq '0.1.0'
+    end
+  end
+
+  describe '#metadata' do
+    let(:path) { 'path/to/manifest.json' }
+    let(:meta) { { 'foo' => 'bar' } }
+
+    let(:data) do
+      {
+        'name' => 'test_manifest',
+        'version' => '0.1.0',
+        'metadata' => meta,
+        'steps' => []
+      }
+    end
+
+    before do
+      @manifest = described_class.new(path, data)
+    end
+
+    it 'returns metadata' do
+      expect(@manifest.metadata).to eq meta
+    end
+  end
+
+  describe '#platform' do
+    let(:path) { 'path/to/manifest.json' }
+    let(:platform) { 'macos' }
+
+    let(:data) do
+      {
+        'name' => 'test_manifest',
+        'version' => '0.1.0',
+        'metadata' => { 'foo' => 'bar' },
+        'platform' => platform,
+        'steps' => []
+      }
+    end
+
+    before do
+      allow(GeneSystem::CLI).to receive(:print_warning)
+      @manifest = described_class.new(path, data)
+    end
+
+    it 'returns platform' do
+      expect(@manifest.platform).to eq platform
+    end
+
+    context 'when platform is unrecognized' do
+      let(:platform) { 'yolosys' }
+
+      before do
+        @platform = @manifest.platform
+      end
+
+      it 'returns platform' do
+        expect(@platform).to eq platform
+      end
+
+      it 'prints unrecognised platform warning' do
+        expect(GeneSystem::CLI)
+          .to have_received(:print_warning)
+          .with("WARN: unrecognized platform: #{platform}")
+      end
+    end
+  end
+
+  describe '#steps' do
+    let(:path) { 'path/to/manifest.json' }
+    let(:data) do
+      {
+        'name' => 'test_manifest',
+        'version' => '0.1.0',
+        'steps' => []
+      }
+    end
+
+    let(:step) { double(GeneSystem::Step) }
+    let(:steps) { [step, step] }
+
+    before do
+      @manifest = described_class.new(path, data)
+      @manifest.instance_variable_set(:@steps, steps)
+    end
+
+    it 'returns all steps by defualt' do
+      expect(@manifest.steps).to eq steps
+    end
+
+    context 'when given a query' do
+      let(:target_step) { double(GeneSystem::Step) }
+      let(:steps) { [step, target_step, step] }
+
+      before do
+        query = ->(step) { step == target_step }
+        @manifest.instance_variable_set(:@steps, steps)
+
+        @result = @manifest.steps(query)
+      end
+
+      it 'returns steps responding to query' do
+        expect(@result).to eq [target_step]
+      end
+    end
+  end
+end

data/spec/gene_system/platform_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+RSpec.describe GeneSystem::Platform do
+  let(:is_posix) { true }
+  before do
+    allow(OS).to receive(:posix?).and_return(is_posix)
+  end
+
+  describe 'initialize' do
+    it 'returns a new platform' do
+      @platform = described_class.new
+      expect(@platform).to be_a(described_class)
+    end
+
+    context 'when system is not posix' do
+      let(:is_posix) { false }
+
+      it 'raises unsuppoorted platform RuntimeError' do
+        expect { described_class.new }.to raise_error(
+          RuntimeError,
+          'unsupported platform'
+        )
+      end
+    end
+  end
+
+  describe '#execute_commands' do
+    let(:cmd) { 'do something' }
+    let(:cmds) { [cmd, cmd] }
+    let(:result) { 0 }
+
+    subject { described_class.new }
+
+    before do
+      allow(subject).to receive(:execute_command)
+        .and_return(result)
+    end
+
+    it 'executes commands' do
+      subject.execute_commands(cmds)
+
+      expect(subject)
+        .to have_received(:execute_command)
+        .with(cmd, {})
+        .twice
+    end
+
+    context 'when command fails' do
+      let(:result) { 1 }
+
+      it 'raises command failed runtime error' do
+        expect { subject.execute_commands(cmds) }.to raise_error(
+          RuntimeError,
+          "command `#{cmd}` failed - returned #{result}"
+        )
+      end
+    end
+  end
+
+  describe '#execute_command' do
+    let(:cmd) { 'do something {{awesome}}' }
+    let(:pid) { 1234 }
+    let(:result) { double(exitstatus: 999) }
+
+    subject { described_class.new }
+
+    before do
+      allow(Process).to receive(:spawn).and_return(pid)
+      allow(Process).to receive(:waitpid2).and_return([pid, result])
+
+      @result = subject.execute_command(cmd, awesome: 'cool')
+    end
+
+    it 'spawns process with command' do
+      expect(Process).to have_received(:spawn).with('do something cool')
+    end
+
+    it 'waits for processs to conclude' do
+      expect(Process).to have_received(:waitpid2).with(pid)
+    end
+
+    it 'returns status' do
+      expect(@result).to eq result.exitstatus
+    end
+  end
+
+  describe '#posix?' do
+    subject { described_class.new }
+
+    it 'returns true if system is posix' do
+      expect(subject.posix?).to be true
+    end
+  end
+end