app_archetype 1.2.3

data/spec/app_archetype/template/helpers_spec.rb

@@ -0,0 +1,251 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Template::Helpers do
+  subject { Object.new.extend(described_class) }
+
+  describe '#dot' do
+    it 'returns an empty string' do
+      expect(subject.dot).to eq ''
+    end
+  end
+
+  describe '#this_year' do
+    let(:time) { Time.new(2002, 10, 31, 2, 2, 2, 0) }
+
+    before do
+      allow(Time).to receive(:now)
+        .and_return(time)
+    end
+
+    it 'returns year' do
+      expect(subject.this_year).to eq '2002'
+    end
+  end
+
+  describe '#timestamp_now' do
+    let(:time) { Time.new(2002, 10, 31, 2, 2, 2, 0) }
+
+    before do
+      allow(Time).to receive(:now)
+        .and_return(time)
+    end
+
+    it 'returns timestamp' do
+      expect(subject.timestamp_now).to eq '20021031020202000'
+    end
+  end
+
+  describe '#timestamp_utc_now' do
+    let(:time) { Time.new(2002, 10, 31, 2, 2, 2, 0) }
+
+    before do
+      allow(Time).to receive(:now)
+        .and_return(time)
+    end
+
+    it 'returns timestamp' do
+      expect(subject.timestamp_utc_now).to eq '20021031020202000'
+    end
+  end
+
+  describe '#random_string' do
+    let(:length) { '10' }
+
+    before do
+      allow(Random).to receive(:rand).and_return 1
+      @string = subject.random_string(length)
+    end
+
+    it 'returns random string of specified length' do
+      expect(@string).to eq 'bbbbbbbbbb'
+    end
+  end
+
+  describe '#randomize' do
+    let(:hex) { '922665344123e551ca40bc4f16ac8e17' }
+    let(:str) { 'a_type_of_thing' }
+
+    before do
+      allow(SecureRandom).to receive(:hex).and_return(hex)
+    end
+
+    it 'adds 5 characters from generated hex on the end of the string' do
+      expect(subject.randomize(str)).to eq 'a_type_of_thing_c8e17'
+    end
+
+    context 'when size is specified' do
+      it 'adds specified number characters from hex on the end of the string' do
+        expect(subject.randomize(str, '3')).to eq 'a_type_of_thing_e17'
+      end
+    end
+
+    context 'when specified size is not an integer' do
+      it 'raises an error' do
+        expect do
+          subject.randomize(str, 'abc')
+        end.to raise_error(RuntimeError, 'size must be an integer')
+      end
+    end
+
+    context 'when size exceeds 32' do
+      it 'raises an error' do
+        expect do
+          subject.randomize(str, '33')
+        end.to raise_error(
+          RuntimeError,
+          'randomize supports up to 32 characters'
+        )
+      end
+    end
+  end
+
+  describe '#upcase' do
+    let(:string) { 'aAaAa' }
+
+    it 'converts string to upper case' do
+      expect(subject.upcase(string)).to eq 'AAAAA'
+    end
+  end
+
+  describe '#downcase' do
+    let(:string) { 'aAaAa' }
+
+    it 'converts string to lower case' do
+      expect(subject.downcase(string)).to eq 'aaaaa'
+    end
+  end
+
+  describe '#join' do
+    it 'joins given strings together by delimiter' do
+      expect(subject.join('|', 'a', 'b', 'c'))
+        .to eq 'a|b|c'
+    end
+  end
+
+  describe '#snake_case' do
+    let(:str) { 'MyProject' }
+
+    it 'snake cases string' do
+      expect(subject.snake_case(str))
+        .to eq 'my_project'
+    end
+
+    context 'when given a title case string' do
+      let(:str) { 'My Project' }
+
+      it 'snake cases string' do
+        expect(subject.snake_case(str))
+          .to eq 'my_project'
+      end
+    end
+
+    context 'when given a dash case string' do
+      let(:str) { 'My-Project' }
+
+      it 'snake cases string' do
+        expect(subject.snake_case(str))
+          .to eq 'my_project'
+      end
+    end
+
+    context 'when given a snake case string' do
+      let(:str) { 'my_project' }
+
+      it 'returns string as is' do
+        expect(subject.snake_case(str)).to eq str
+      end
+    end
+  end
+
+  describe '#dash_case' do
+    let(:str) { 'my Project' }
+
+    it 'dash cases string' do
+      expect(subject.dash_case(str))
+        .to eq 'my-project'
+    end
+
+    context 'when given a title case string' do
+      let(:str) { 'My Project' }
+
+      it 'dash cases string' do
+        expect(subject.dash_case(str))
+          .to eq 'my-project'
+      end
+    end
+
+    context 'when given a snake case string' do
+      let(:str) { 'my_project' }
+
+      it 'dash cases string' do
+        expect(subject.dash_case(str))
+          .to eq 'my-project'
+      end
+    end
+
+    context 'when given a dash case string' do
+      let(:str) { 'my-project' }
+
+      it 'returns string as is' do
+        expect(subject.dash_case(str)).to eq str
+      end
+    end
+  end
+
+  describe '#camel_case' do
+    let(:str) { 'My Project' }
+
+    it 'camel cases string' do
+      expect(subject.camel_case(str))
+        .to eq 'MyProject'
+    end
+
+    context 'when given a camel case string' do
+      let(:str) { 'MyProject' }
+
+      it 'returns string as is' do
+        expect(subject.camel_case(str)).to eq str
+      end
+    end
+  end
+
+  describe '#snake_to_camel' do
+    let(:input) { 'a_type_of_thing' }
+
+    it 'camelizes the given string' do
+      expect(subject.snake_to_camel(input)).to eq 'ATypeOfThing'
+    end
+  end
+
+  describe '#pluralize' do
+    let(:input) { 'Apple' }
+
+    it 'pluralizes the given string' do
+      expect(subject.pluralize(input)).to eq 'Apples'
+    end
+
+    context 'when string ends in y' do
+      let(:input) { 'Quantity' }
+
+      it 'pluralizes the given string' do
+        expect(subject.pluralize(input)).to eq 'Quantities'
+      end
+    end
+  end
+
+  describe '#singularize' do
+    let(:input) { 'Bananas' }
+
+    it 'singularizes the given string' do
+      expect(subject.singularize(input)).to eq 'Banana'
+    end
+
+    context 'when string ends in ies' do
+      let(:input) { 'Quantities' }
+
+      it 'singularizes the given string' do
+        expect(subject.singularize(input)).to eq 'Quantity'
+      end
+    end
+  end
+end

data/spec/app_archetype/template/manifest_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Template::Manifest do
+  describe '.new_from_file' do
+    let(:file_path) { 'path/to/manifest' }
+    let(:exist) { true }
+    let(:manifest_name) { 'manifest name' }
+
+    let(:app_archetype_meta) do
+      {
+        'app_archetype' => {
+          'version' => AppArchetype::VERSION
+        }
+      }
+    end
+
+    let(:version) { '0.0.1' }
+    let(:vars) do
+      {
+        'foo' => {
+          'description' => 'a foo',
+          'default' => 'bar'
+        },
+        'bar' => {
+          'description' => 'a bar',
+          'default' => 'foo'
+        }
+      }
+    end
+    let(:content) do
+      {
+        'name' => manifest_name,
+        'version' => version,
+        'metadata' => app_archetype_meta,
+        'variables' => vars
+      }.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 AppArchetype::Template::Manifest
+      end
+
+      it 'has version' do
+        expect(@parsed.version).to eq version
+      end
+
+      it 'has variables' do
+        expect(@parsed.variables)
+          .to be_a AppArchetype::Template::VariableManager
+      end
+    end
+
+    context 'when manifest is from a later version of app archetype' do
+      let(:app_archetype_meta) do
+        {
+          'app_archetype' => {
+            '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 app archetype'
+      end
+    end
+
+    context 'when manifest is from an incompatible version of app archetype' do
+      let(:app_archetype_meta) do
+        {
+          'app_archetype' => {
+            'version' => '0.9.9'
+          }
+        }
+      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 app archetype'
+      end
+    end
+
+    context 'when app_archetype metadata is missing' do
+      let(:app_archetype_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 app archetype'
+      end
+    end
+  end
+
+  subject { described_class.new(path, data) }
+
+  describe '#name' do
+    let(:path) { 'path/to/manifest.json' }
+
+    let(:data) do
+      {
+        'name' => 'test_manifest',
+        'version' => '0.1.0',
+        'variables' => {}
+      }
+    end
+
+    it 'returns name' do
+      expect(subject.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',
+        'variables' => {}
+      }
+    end
+
+    it 'returns version' do
+      expect(subject.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,
+        'variables' => {}
+      }
+    end
+
+    it 'returns metadata' do
+      expect(subject.metadata).to eq meta
+    end
+  end
+
+  describe '#template' do
+    let(:path) { 'path/to/manifest.json' }
+
+    let(:data) do
+      {
+        'name' => 'test_manifest',
+        'version' => '0.1.0',
+        'variables' => {}
+      }
+    end
+
+    let(:exist) { true }
+    let(:template) { double(AppArchetype::Template::Source) }
+
+    before do
+      allow(File).to receive(:exist?).and_return(exist)
+    end
+
+    it 'loads template adjacent to manifest' do
+      expect(subject.template.path).to eq('path/to/template')
+    end
+
+    context 'when template files do not exist' do
+      let(:exist) { false }
+
+      it 'raises cannot find template error' do
+        expect { subject.template }.to raise_error(
+          RuntimeError,
+          'cannot find template for manifest test_manifest'
+        )
+      end
+    end
+  end
+
+  describe 'validate' do
+    let(:path) { 'path/to/manifest.json' }
+    let(:data) { {} }
+    let(:result) { [] }
+
+    before do
+      allow(JSON::Validator).to receive(:fully_validate).and_return(result)
+      subject.validate
+    end
+
+    it 'runs json schema validation with manifest schema' do
+      expect(JSON::Validator).to have_received(:fully_validate)
+        .with(
+          AppArchetype::Template::Manifest::SCHEMA,
+          data.to_json,
+          strict: true
+        )
+    end
+  end
+
+  describe '#valid?' do
+    let(:path) { 'path/to/manifest.json' }
+    let(:data) { {} }
+    let(:validation_results) { [] }
+
+    before do
+      allow(subject).to receive(:validate).and_return(validation_results)
+    end
+
+    context 'when manifest is valid' do
+      it 'returns true' do
+        expect(subject.valid?).to be true
+      end
+    end
+
+    context 'when manifest is invalid' do
+      let(:validation_results) { ['there was a validation error'] }
+      it 'returns true' do
+        expect(subject.valid?).to be false
+      end
+    end
+  end
+end