app_archetype 1.2.8 → 1.3.0

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

data/spec/app_archetype/commands/list_templates_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Commands::ListTemplates do
+  let(:options) { Hashie::Mash.new }
+
+  let(:manifest_list_table) do
+    <<~TABLE
+      NAME          VERSION
+      some-manifest 1.0.0  
+    TABLE
+  end
+
+  let(:manager) { double(AppArchetype::TemplateManager) }
+  let(:manifests) { [manifest] }
+
+  let(:manifest) do
+    double(
+      AppArchetype::Template::Manifest,
+      name: 'some-manifest',
+      version: '1.0.0'
+    )
+  end
+
+  subject { described_class.new(manager, options) }
+
+  before do
+    allow(manager)
+      .to receive(:manifests)
+      .and_return(manifests)
+
+    allow(TTY::Table).to receive(:new).and_call_original
+    allow(subject).to receive(:puts)
+  end
+
+  describe '#run' do
+    before { subject.run }
+
+    it 'retrieves manifests from manager' do
+      expect(manager).to have_received(:manifests)
+    end
+
+    it 'renders table' do
+      expect(TTY::Table).to have_received(:new).with(
+        header: AppArchetype::Commands::ListTemplates::RESULT_HEADER,
+        rows: [['some-manifest', '1.0.0']]
+      )
+    end
+
+    it 'prints table to STDOUT' do
+      expect(subject)
+        .to have_received(:puts)
+        .with(manifest_list_table.strip)
+    end
+  end
+end

data/spec/app_archetype/commands/new_template_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Commands::NewTemplate do
+  let(:template_dir) { 'path/to/templates' }
+  let(:options) { Hashie::Mash.new }
+  let(:prompt) { double(TTY::Prompt) }
+
+  subject { described_class.new(template_dir, options) }
+
+  before do
+    subject.instance_variable_set(:@prompt, prompt)
+  end
+
+  describe '#run' do
+    let(:template_name) { 'new-template' }
+    let(:out_dir) { File.join(template_dir, template_name) }
+
+    before do
+      allow(FileUtils).to receive(:mkdir_p)
+      allow(AppArchetype::Generators)
+        .to receive(:render_empty_template)
+      allow(subject).to receive(:puts)
+    end
+
+    context 'when template name is provided' do
+      let(:options) do
+        Hashie::Mash.new(
+          name: template_name
+        )
+      end
+
+      before { subject.run }
+
+      it 'makes the folder' do
+        expect(FileUtils)
+          .to have_received(:mkdir_p)
+          .with(out_dir)
+      end
+
+      it 'generates the empty template' do
+        expect(AppArchetype::Generators)
+          .to have_received(:render_empty_template)
+          .with(template_name, out_dir)
+      end
+
+      it 'prints success message' do
+        expect(subject)
+          .to have_received(:puts)
+          .with("✔ Template `#{template_name}` created at #{out_dir}")
+      end
+    end
+
+    context 'when template name is not provided' do
+      before do
+        allow(prompt).to receive(:ask).and_return(template_name)
+        subject.run
+      end
+
+      it 'prompts user for a new name' do
+        expect(prompt)
+          .to have_received(:ask)
+          .with('Please enter a name for the new template')
+      end
+
+      it 'makes the folder' do
+        expect(FileUtils)
+          .to have_received(:mkdir_p)
+          .with(out_dir)
+      end
+
+      it 'generates the empty template' do
+        expect(AppArchetype::Generators)
+          .to have_received(:render_empty_template)
+          .with(template_name, out_dir)
+      end
+
+      it 'prints success message' do
+        expect(subject)
+          .to have_received(:puts)
+          .with("✔ Template `#{template_name}` created at #{out_dir}")
+      end
+    end
+  end
+end

data/spec/app_archetype/commands/open_manifest_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Commands::OpenManifest do
+  let(:manager) { AppArchetype::TemplateManager }
+  let(:editor) { 'vi' }
+  let(:options) { Hashie::Mash.new }
+  let(:prompt) { double(TTY::Prompt) }
+
+  subject { described_class.new(manager, editor, options) }
+
+  before do
+    subject.instance_variable_set(:@prompt, prompt)
+  end
+
+  describe '#run' do
+    let(:template_name) { 'template-name' }
+    let(:manifest_path) { 'path/to/manifest' }
+    let(:editor) { 'vi' }
+    let(:manifest) { double(AppArchetype::Template::Manifest) }
+
+    before do
+      allow(prompt)
+        .to receive(:select)
+        .and_return(template_name)
+
+      allow(manager)
+        .to receive(:find_by_name)
+        .and_return(manifest)
+
+      allow(manager)
+        .to receive(:manifest_names)
+        .and_return([template_name])
+
+      allow(manifest)
+        .to receive(:path)
+        .and_return(manifest_path)
+
+      allow(Process).to receive(:spawn)
+      allow(Process).to receive(:waitpid)
+
+      allow(subject).to receive(:puts)
+
+      subject.run
+    end
+
+    context 'when name is provided in options' do
+      describe 'when the template is found' do
+        it 'finds template by name' do
+          expect(manager)
+            .to have_received(:find_by_name)
+            .with(template_name)
+        end
+
+        it 'runs editor process' do
+          expect(Process)
+            .to have_received(:spawn)
+            .with("#{editor} #{manifest_path}")
+        end
+
+        it 'waits for process' do
+          expect(Process)
+            .to have_received(:waitpid)
+        end
+      end
+
+      describe 'when the template is not found' do
+        let(:manifest) { nil }
+
+        it 'attempts to find template by name' do
+          expect(manager)
+            .to have_received(:find_by_name)
+            .with(template_name)
+        end
+
+        it 'prints manifest not found message' do
+          expect(subject)
+            .to have_received(:puts)
+            .with("✖ No manifests with name `#{template_name}` found.")
+        end
+
+        it 'does not start editor process' do
+          expect(Process)
+            .not_to have_received(:spawn)
+        end
+      end
+    end
+
+    context 'when name is not provided in options' do
+      it 'prompts user to choose template' do
+        expect(prompt)
+          .to have_received(:select)
+          .with('Please choose manifest', [template_name])
+      end
+
+      it 'finds template by name' do
+        expect(manager)
+          .to have_received(:find_by_name)
+          .with(template_name)
+      end
+
+      it 'starts editor process' do
+        expect(Process)
+          .to have_received(:spawn)
+          .with("#{editor} #{manifest_path}")
+      end
+
+      it 'waits for process' do
+        expect(Process)
+          .to have_received(:waitpid)
+      end
+    end
+  end
+end

data/spec/app_archetype/commands/print_path_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Commands::PrintPath do
+  let(:options) { Hashie::Mash.new }
+  let(:template_dir) { '/path/to/templates' }
+
+  subject { described_class.new(template_dir, options) }
+
+  before do
+    allow(subject).to receive(:puts)
+  end
+
+  describe '#run' do
+    before { subject.run }
+
+    it 'prints given template path to STDOUT' do
+      expect(subject)
+        .to have_received(:puts)
+        .with(template_dir)
+    end
+  end
+end

data/spec/app_archetype/commands/print_template_variables_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Commands::PrintTemplateVariables 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_manifest) { nil }
+
+    let(:manifest_name) { 'some-template' }
+    let(:manifest_version) { '1.0.0' }
+
+    let(:manifest) do
+      double(
+        AppArchetype::Template::Manifest,
+        name: manifest_name,
+        version: manifest_version,
+        variables: variables
+      )
+    end
+
+    let(:variable_name) { 'script_name' }
+    let(:variable_description) { 'Name of script' }
+    let(:variable_default) { 'bashy-bash' }
+
+    let(:variables) do
+      double(AppArchetype::Template::VariableManager)
+    end
+
+    let(:variable) do
+      AppArchetype::Template::Variable.new(
+        variable_name,
+        {
+          name: variable_name,
+          description: variable_description,
+          default: variable_default
+        }
+      )
+    end
+
+    before do
+      allow(prompt)
+        .to receive(:select)
+        .and_return(prompt_response)
+
+      allow(manager)
+        .to receive(:manifest_names)
+        .and_return([manifest_name])
+
+      allow(manager)
+        .to receive(:find_by_name)
+        .and_return(found_manifest)
+
+      allow(variables)
+        .to receive(:all)
+        .and_return([variable])
+
+      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(:find_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_manifest) { manifest }
+
+        before { subject.run }
+
+        it 'uses manager to search for template by name' do
+          expect(manager)
+            .to have_received(:find_by_name)
+            .with(manifest_name)
+        end
+
+        it 'prints manifest list table' do
+          expected_table = <<~TABLE
+            NAME        DESCRIPTION    DEFAULT   
+            #{variable_name} #{variable_description} #{variable_default}
+          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(:select).and_return(manifest_name)
+        subject.run
+      end
+
+      it 'prompts user for a template name' do
+        expect(prompt)
+          .to have_received(:select)
+          .with('Please choose manifest', [manifest_name])
+      end
+
+      it 'uses manager to search for template by name' do
+        expect(manager)
+          .to have_received(:find_by_name)
+          .with(manifest_name)
+      end
+
+      describe 'when there is a result' do
+        let(:found_manifest) { manifest }
+
+        it 'prints manifest list table' do
+          expected_table = <<~TABLE
+            NAME        DESCRIPTION    DEFAULT   
+            #{variable_name} #{variable_description} #{variable_default}
+          TABLE
+
+          expect(subject)
+            .to have_received(:puts)
+            .with(expected_table.strip)
+        end
+      end
+
+      describe 'when there is no result' 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

data/spec/app_archetype/commands/print_version_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Commands::PrintVersion do
+  let(:options) { Hashie::Mash.new }
+
+  subject { described_class.new(options) }
+
+  before do
+    allow(subject).to receive(:puts)
+  end
+
+  describe '#run' do
+    before { subject.run }
+
+    it 'prints current version to STDOUT' do
+      expect(subject)
+        .to have_received(:puts)
+        .with(AppArchetype::VERSION)
+    end
+  end
+end