app_archetype 1.2.8 → 1.4.2

data/spec/app_archetype/cli_spec.rb

@@ -1,132 +1,363 @@
 require 'spec_helper'
 
 RSpec.describe AppArchetype::CLI do
+  let(:options) { Hashie::Mash.new }
+
   subject { described_class.new }
 
-  describe '.manager' do
+  before do
+    allow(subject).to receive(:options)
+      .and_return(options)
+  end
+
+  describe '#version' do
+    let(:command) { double }
+
+    before do
+      allow(command).to receive(:run)
+      allow(AppArchetype::Commands::PrintVersion)
+        .to receive(:new)
+        .and_return(command)
+
+      subject.version
+    end
+
+    it 'passes options to command' do
+      expect(AppArchetype::Commands::PrintVersion)
+        .to have_received(:new).with(options)
+    end
+
+    it 'runs command' do
+      expect(command).to have_received(:run)
+    end
+  end
+
+  describe '#list' do
+    let(:command) { double }
     let(:manager) { double }
+
+    before do
+      allow(command).to receive(:run)
+      allow(subject).to receive(:manager).and_return(manager)
+      allow(AppArchetype::Commands::ListTemplates)
+        .to receive(:new)
+        .and_return(command)
+
+      subject.list
+    end
+
+    it 'passes manager and options to command' do
+      expect(AppArchetype::Commands::ListTemplates)
+        .to have_received(:new).with(manager, options)
+    end
+
+    it 'runs command' do
+      expect(command).to have_received(:run)
+    end
+  end
+
+  describe '#path' do
+    let(:command) { double }
     let(:template_dir) { 'path/to/templates' }
 
     before do
-      allow(described_class).to receive(:template_dir).and_return(template_dir)
-      allow(AppArchetype::TemplateManager).to receive(:new).and_return(manager)
+      allow(command).to receive(:run)
+      allow(subject).to receive(:template_dir)
+        .and_return(template_dir)
 
-      allow(manager).to receive(:load)
+      allow(AppArchetype::Commands::PrintPath)
+        .to receive(:new)
+        .and_return(command)
 
-      @manager = described_class.manager
+      subject.path
     end
 
-    it 'creates a manager' do
-      expect(AppArchetype::TemplateManager)
-        .to have_received(:new)
-        .with(template_dir)
+    it 'passes template path and options to command' do
+      expect(AppArchetype::Commands::PrintPath)
+        .to have_received(:new).with(template_dir, options)
+    end
 
-      expect(manager).to have_received(:load)
-      expect(@manager).to eq manager
+    it 'runs command' do
+      expect(command).to have_received(:run)
     end
   end
 
-  describe '.template_dir' do
-    let(:env_template_dir) { 'path/to/templates' }
-    let(:exist) { true }
+  describe '#open' do
+    let(:command) { double }
+    let(:manager) { double }
+    let(:editor) { 'vi' }
 
     before do
-      allow(ENV).to receive(:[])
-        .with('ARCHETYPE_TEMPLATE_DIR')
-        .and_return(env_template_dir)
+      allow(command).to receive(:run)
+      allow(subject).to receive(:manager).and_return(manager)
+      allow(subject).to receive(:editor).and_return(editor)
+      allow(AppArchetype::Commands::OpenManifest)
+        .to receive(:new)
+        .and_return(command)
+
+      subject.open
+    end
+
+    it 'passes manager, editor and options to command' do
+      expect(AppArchetype::Commands::OpenManifest)
+        .to have_received(:new).with(manager, editor, options)
+    end
+
+    it 'runs command' do
+      expect(command).to have_received(:run)
+    end
+  end
+
+  describe '#new' do
+    let(:command) { double }
+    let(:template_dir) { 'path/to/templates' }
+
+    before do
+      allow(command).to receive(:run)
+      allow(subject).to receive(:template_dir)
+        .and_return(template_dir)
+
+      allow(AppArchetype::Commands::NewTemplate)
+        .to receive(:new)
+        .and_return(command)
 
-      allow(File).to receive(:exist?).and_return(exist)
+      subject.new
     end
 
-    it 'returns template dir' do
-      expect(described_class.template_dir).to eq env_template_dir
+    it 'passes template path and options to command' do
+      expect(AppArchetype::Commands::NewTemplate)
+        .to have_received(:new).with(template_dir, options)
     end
 
-    context 'when ARCHETYPE_TEMPLATE_DIR environment variable not set' do
-      let(:env_template_dir) { nil }
+    it 'runs command' do
+      expect(command).to have_received(:run)
+    end
+  end
+
+  describe '#delete' do
+    let(:command) { double }
+    let(:manager) { double }
+
+    before do
+      allow(command).to receive(:run)
+      allow(subject).to receive(:manager).and_return(manager)
+      allow(AppArchetype::Commands::DeleteTemplate)
+        .to receive(:new)
+        .and_return(command)
+
+      subject.delete
+    end
+
+    it 'passes manager and options to command' do
+      expect(AppArchetype::Commands::DeleteTemplate)
+        .to have_received(:new).with(manager, options)
+    end
+
+    it 'runs command' do
+      expect(command).to have_received(:run)
+    end
+  end
+
+  describe '#variables' do
+    let(:command) { double }
+    let(:manager) { double }
+
+    before do
+      allow(command).to receive(:run)
+      allow(subject).to receive(:manager).and_return(manager)
+      allow(AppArchetype::Commands::PrintTemplateVariables)
+        .to receive(:new)
+        .and_return(command)
 
-      it 'raises environment not set error' do
-        expect { described_class.template_dir }.to raise_error(
+      subject.variables
+    end
+
+    it 'passes manager and options to command' do
+      expect(AppArchetype::Commands::PrintTemplateVariables)
+        .to have_received(:new).with(manager, options)
+    end
+
+    it 'runs command' do
+      expect(command).to have_received(:run)
+    end
+  end
+
+  describe '#find' do
+    let(:command) { double }
+    let(:manager) { double }
+
+    before do
+      allow(command).to receive(:run)
+      allow(subject).to receive(:manager).and_return(manager)
+      allow(AppArchetype::Commands::FindTemplates)
+        .to receive(:new)
+        .and_return(command)
+
+      subject.find
+    end
+
+    it 'passes manager and options to command' do
+      expect(AppArchetype::Commands::FindTemplates)
+        .to have_received(:new).with(manager, options)
+    end
+
+    it 'runs command' do
+      expect(command).to have_received(:run)
+    end
+  end
+
+  describe '#render' do
+    let(:command) { double }
+    let(:manager) { double }
+    let(:out_path) { 'path/to/out' }
+    let(:options) { Hashie::Mash.new(out: out_path) }
+
+    before do
+      allow(command).to receive(:run)
+      allow(subject).to receive(:manager).and_return(manager)
+      allow(AppArchetype::Commands::RenderTemplate)
+        .to receive(:new)
+        .and_return(command)
+
+      subject.render
+    end
+
+    it 'passes manager, out path and options to command' do
+      expect(AppArchetype::Commands::RenderTemplate)
+        .to have_received(:new).with(manager, out_path, options)
+    end
+
+    it 'runs command' do
+      expect(command).to have_received(:run)
+    end
+  end
+
+  describe '#template_dir' do
+    let(:template_dir) { 'path/to/template/dir' }
+    let(:template_dir_exist) { false }
+
+    before do
+      allow(ENV)
+        .to receive(:[])
+        .with('ARCHETYPE_TEMPLATE_DIR')
+        .and_return(template_dir)
+
+      allow(File)
+        .to receive(:exist?)
+        .and_return(template_dir_exist)
+    end
+
+    context 'when environment variable not set' do
+      let(:template_dir) { nil }
+
+      it 'raises env var not set runtime error' do
+        expect do
+          subject.template_dir
+        end.to raise_error(
           RuntimeError,
           'ARCHETYPE_TEMPLATE_DIR environment variable not set'
         )
       end
     end
 
-    context 'when templates do not exist' do
-      let(:exist) { false }
-
-      it 'raises environment not set error' do
-        expect { described_class.template_dir }.to raise_error(
+    context 'when template directory does not exist' do
+      it 'raises env var not exist runtime error' do
+        expect do
+          subject.template_dir
+        end.to raise_error(
           RuntimeError,
-          "ARCHETYPE_TEMPLATE_DIR #{env_template_dir} does not exist"
+          "ARCHETYPE_TEMPLATE_DIR #{template_dir} does not exist"
         )
       end
     end
+
+    context 'when environment variable set and directory exists' do
+      let(:template_dir_exist) { true }
+
+      it 'returns template dir' do
+        expect(subject.template_dir).to eq template_dir
+      end
+    end
   end
 
-  describe '.editor' do
-    let(:env_editor) { 'ivm' }
-    let(:exit_status) { 0 }
+  describe '#editor' do
+    let(:editor) { 'vi' }
+    let(:editor_check_process_result) { double }
 
     before do
-      allow(ENV).to receive(:[])
+      allow(ENV)
+        .to receive(:[])
         .with('ARCHETYPE_EDITOR')
-        .and_return(env_editor)
-
-      allow(described_class).to receive(:`)
-      allow($?).to receive(:exitstatus).and_return(exit_status)
-    end
+        .and_return(editor)
 
-    it 'returns editor' do
-      expect(described_class.editor).to eq env_editor
+      allow(subject).to receive(:puts)
     end
 
-    context 'when ARCHETYPE_EDITOR environment variable not set' do
-      let(:env_editor) { nil }
+    context 'when editor is not set' do
+      let(:editor) { nil }
 
-      it 'raises environment not set error' do
-        expect { described_class.editor }.to raise_error(
+      it 'raises archetype editor runtime error' do
+        expect do
+          subject.editor
+        end.to raise_error(
           RuntimeError,
           'ARCHETYPE_EDITOR environment variable not set'
         )
       end
     end
 
-    context 'when editor check does not pass' do
-      let(:exit_status) { 1 }
+    context 'when check exit status is non zero' do
+      let(:editor) { 'not-valid-editor' }
 
-      before do
-        allow(AppArchetype::CLI).to receive(:print_warning)
-        described_class.editor
-      end
+      it 'warns user that the editor is not installed correctly' do
+        subject.editor
 
-      it 'logs a warning' do
-        expect(AppArchetype::CLI)
-          .to have_received(:print_warning)
+        expect(subject)
+          .to have_received(:puts)
           .with(
-            "WARN: Configured editor #{env_editor} is not installed correctly "\
+            "WARN: Configured editor #{editor} is not installed correctly "\
             'please check your configuration'
           )
       end
     end
-  end
 
-  describe '.exit_on_failure?' do
-    it 'returns true' do
-      expect(described_class.exit_on_failure?).to be true
+    context 'when editor is set and check exit status is zero' do
+      it 'returns editor' do
+        expect(subject.editor).to eq editor
+      end
     end
   end
 
-  describe '#version' do
+  describe '#manager' do
+    let(:template_dir) { 'path/to/template/dir' }
+    let(:manager) { double(AppArchetype::TemplateManager) }
+
     before do
-      allow(subject).to receive(:print_message)
-      subject.version
+      allow(subject)
+        .to receive(:template_dir)
+        .and_return(template_dir)
+
+      allow(AppArchetype::TemplateManager)
+        .to receive(:new)
+        .and_return(manager)
+
+      allow(manager).to receive(:load)
+
+      @manager = subject.manager
     end
 
-    it 'prints current version number' do
-      expect(subject).to have_received(:print_message)
-        .with(AppArchetype::VERSION)
+    it 'creates a new template with template dir' do
+      expect(AppArchetype::TemplateManager)
+        .to have_received(:new)
+        .with(template_dir)
+    end
+
+    it 'loads manager' do
+      expect(manager).to have_received(:load)
+    end
+
+    it 'returns manager' do
+      expect(@manager).to eq manager
     end
   end
 end

data/spec/app_archetype/commands/delete_template_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Commands::DeleteTemplate do
+  let(:manager) { double(AppArchetype::TemplateManager) }
+  let(:options) { Hashie::Mash.new }
+  let(:prompt) { double(TTY::Prompt) }
+
+  subject { described_class.new(manager, options) }
+
+  before do
+    subject.instance_variable_set(:@prompt, prompt)
+  end
+
+  describe '#run' do
+    let(:ok_to_proceed) { true }
+    let(:manifest) { double(AppArchetype::Template::Manifest) }
+    let(:manifest_parent_path) { 'path/to/template' }
+    let(:manifest_name) { 'some-manifest' }
+
+    before do
+      allow(manager).to receive(:find_by_name).and_return(manifest)
+      allow(manager).to receive(:manifest_names).and_return([manifest_name])
+
+      allow(prompt).to receive(:select).and_return(manifest_name)
+      allow(prompt).to receive(:yes?).and_return(ok_to_proceed)
+
+      allow(manifest)
+        .to receive(:parent_path)
+        .and_return(manifest_parent_path)
+
+      allow(FileUtils).to receive(:rm_rf)
+      allow(subject).to receive(:puts)
+      subject.run
+    end
+
+    context 'when name is provided in options' do
+      let(:options) do
+        Hashie::Mash.new(
+          name: manifest_name
+        )
+      end
+
+      describe 'and the manifest is found' do
+        it 'finds the manifest' do
+          expect(manager)
+            .to have_received(:find_by_name)
+            .with(manifest_name)
+        end
+
+        it 'asks whether to proceed' do
+          expect(prompt)
+            .to have_received(:yes?)
+            .with("Are you sure you want to delete #{manifest_name}?")
+        end
+
+        describe 'when we should delete the template' do
+          it 'removes template' do
+            expect(FileUtils).to have_received(:rm_rf)
+              .with(manifest_parent_path)
+          end
+
+          it 'prints success message' do
+            expect(subject).to have_received(:puts)
+              .with("✔ Template `#{manifest_name}` has been removed")
+          end
+        end
+
+        describe 'when we should not delete the template' do
+          let(:ok_to_proceed) { false }
+
+          it 'does not remove the template' do
+            expect(FileUtils).not_to have_received(:rm_rf)
+          end
+        end
+      end
+
+      describe 'and the manifest is not found' do
+        let(:manifest) { nil }
+
+        it 'attempts to find the manifest' do
+          expect(manager)
+            .to have_received(:find_by_name)
+            .with(manifest_name)
+        end
+
+        it 'prints manifest not found message' do
+          expect(subject).to have_received(:puts)
+            .with("✖ No template with name `#{manifest_name}` found.")
+        end
+      end
+    end
+
+    context 'when name is not provided in options' do
+      before do
+        allow(prompt)
+          .to receive(:select)
+          .and_return(manifest_name)
+      end
+
+      it 'prompts the user to choose the manifest for deletion' do
+        expect(prompt)
+          .to have_received(:select)
+          .with('Please choose template for deletion', [manifest_name])
+      end
+
+      it 'asks whether to proceed' do
+        expect(prompt).to have_received(:yes?)
+          .with("Are you sure you want to delete #{manifest_name}?")
+      end
+
+      describe 'when we should delete the template' do
+        it 'removes template' do
+          expect(FileUtils).to have_received(:rm_rf)
+            .with(manifest_parent_path)
+        end
+
+        it 'prints success message' do
+          expect(subject).to have_received(:puts)
+            .with("✔ Template `#{manifest_name}` has been removed")
+        end
+      end
+
+      describe 'when we should not delete the template' do
+        let(:ok_to_proceed) { false }
+
+        it 'does not remove the template' do
+          expect(FileUtils).not_to have_received(:rm_rf)
+        end
+      end
+    end
+  end
+end

data/spec/app_archetype/commands/find_templates_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Commands::FindTemplates do
+  let(:manager) { double(AppArchetype::TemplateManager) }
+  let(:options) { Hashie::Mash.new }
+  let(:prompt) { double(TTY::Prompt) }
+
+  subject { described_class.new(manager, options) }
+
+  before do
+    subject.instance_variable_set(:@prompt, prompt)
+  end
+
+  describe '#run' do
+    let(:prompt_response) { nil }
+    let(:found_manifests) { [] }
+
+    let(:manifest_name) { 'some-template' }
+    let(:manifest_version) { '1.0.0' }
+
+    let(:manifest) do
+      double(
+        AppArchetype::Template::Manifest,
+        name: manifest_name,
+        version: manifest_version
+      )
+    end
+
+    before do
+      allow(prompt)
+        .to receive(:ask)
+        .and_return(prompt_response)
+
+      allow(manager)
+        .to receive(:search_by_name)
+        .and_return(found_manifests)
+
+      allow(subject).to receive(:puts)
+    end
+
+    context 'when name is provided in options' do
+      let(:options) do
+        Hashie::Mash.new(
+          name: manifest_name
+        )
+      end
+
+      describe 'and the template is not found' do
+        before { subject.run }
+
+        it 'uses manager to search for template by name' do
+          expect(manager)
+            .to have_received(:search_by_name)
+            .with(manifest_name)
+        end
+
+        it 'prints no manifests found message' do
+          expect(subject)
+            .to have_received(:puts)
+            .with("✖ No manifests with name `#{manifest_name}` found.")
+        end
+      end
+
+      describe 'and the template is found' do
+        let(:found_manifests) { [manifest] }
+
+        before { subject.run }
+
+        it 'uses manager to search for template by name' do
+          expect(manager)
+            .to have_received(:search_by_name)
+            .with(manifest_name)
+        end
+
+        it 'prints manifest list table' do
+          expected_table = <<~TABLE
+            NAME          VERSION
+            #{manifest_name} #{manifest_version}
+          TABLE
+
+          expect(subject)
+            .to have_received(:puts)
+            .with(expected_table.strip)
+        end
+      end
+    end
+
+    context 'when the name is not provided in options' do
+      before do
+        allow(prompt).to receive(:ask).and_return(manifest_name)
+        subject.run
+      end
+
+      it 'prompts user for a template name' do
+        expect(prompt)
+          .to have_received(:ask)
+          .with('Please enter a template name')
+      end
+
+      it 'uses manager to search for template by name' do
+        expect(manager)
+          .to have_received(:search_by_name)
+          .with(manifest_name)
+      end
+
+      describe 'when there are results' do
+        let(:found_manifests) { [manifest] }
+
+        it 'prints manifest list table' do
+          expected_table = <<~TABLE
+            NAME          VERSION
+            #{manifest_name} #{manifest_version}
+          TABLE
+
+          expect(subject)
+            .to have_received(:puts)
+            .with(expected_table.strip)
+        end
+      end
+
+      describe 'when there are no results' do
+        it 'prints no manifests found messsage' do
+          expect(subject)
+            .to have_received(:puts)
+            .with("✖ No manifests with name `#{manifest_name}` found.")
+        end
+      end
+    end
+  end
+end