howitzer 2.2.0 → 2.3.0

data/spec/unit/generators/web_generator_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Generators' do
-  let(:destination) { Howitzer::BaseGenerator.destination }
-  let(:output) { StringIO.new }
-  subject { file_tree_info(destination) }
-  before do
-    Howitzer::BaseGenerator.logger = output
-    generator_name.new({})
-  end
-  after { FileUtils.rm_r(destination) }
-
-  describe Howitzer::WebGenerator do
-    let(:generator_name) { described_class }
-    let(:expected_result) do
-      [
-        {
-          name: '/web',
-          is_directory: true
-        },
-        {
-          name: '/web/pages',
-          is_directory: true
-        },
-        {
-          name: '/web/pages/example_page.rb',
-          is_directory: false,
-          size: template_file_size('web', 'example_page.rb')
-        },
-        {
-          name: '/web/sections',
-          is_directory: true
-        },
-        {
-          name: '/web/sections/menu_section.rb',
-          is_directory: false,
-          size: template_file_size('web', 'menu_section.rb')
-        }
-      ]
-    end
-    it { is_expected.to eql(expected_result) }
-    describe 'output' do
-      let(:expected_output) do
-        "#{ColorizedString.new('  * PageOriented pattern structure generation ...').light_cyan}
-      #{ColorizedString.new('Added').light_green} 'web/pages/example_page.rb' file
-      #{ColorizedString.new('Added').light_green} 'web/sections/menu_section.rb' file\n"
-      end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
-    end
-  end
-end

data/spec/unit/lib/cache_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-require 'howitzer/cache'
-
-RSpec.describe Howitzer::Cache do
-  before { described_class.data.clear }
-  describe '.store' do
-    subject { described_class.store(ns, 7, :halt) }
-    context 'when namespace specified' do
-      let(:ns) { :user }
-      it 'should return value' do
-        is_expected.to eql(:halt)
-      end
-      it 'should store namespace value' do
-        subject
-        expect(described_class.data[:user]).to eql(7 => :halt)
-      end
-    end
-    context 'when namespace empty' do
-      let(:ns) { nil }
-      it { expect { subject }.to raise_error(Howitzer::NoDataError, 'Data storage namespace can not be empty') }
-    end
-  end
-  describe '.extract' do
-    subject { described_class.extract(ns, key) }
-    before { described_class.data[:user] = { 7 => :exit } }
-    describe 'when namespace specified' do
-      let(:ns) { :user }
-      context 'and namespace key found' do
-        let(:key) { 7 }
-        it { is_expected.to eql(:exit) }
-      end
-      context 'and namespace key not found' do
-        let(:key) { 5 }
-        it { is_expected.to be_nil }
-      end
-      context 'but namespace key not specified' do
-        let(:key) { nil }
-        it { is_expected.to eql(7 => :exit) }
-      end
-    end
-    context 'when namespace not found' do
-      let(:ns) { :guest }
-      let(:key) { 11 }
-      it { is_expected.to be_nil }
-    end
-    context 'when namespace not specified' do
-      let(:ns) { nil }
-      let(:key) { nil }
-      it { expect { subject }.to raise_error(Howitzer::NoDataError, 'Data storage namespace can not be empty') }
-    end
-  end
-  describe '.clear_ns' do
-    subject { described_class.clear_ns(:user) }
-    before { described_class.data[:user] = { 7 => :exit } }
-    it 'should return empty hash' do
-      subject
-      data = described_class.instance_variable_get(:@data)
-      expect(data[:user]).to eql({})
-    end
-  end
-  describe '.clear_all_ns' do
-    before do
-      described_class.store(:cloud, :status, false)
-      described_class.store(:foo, 'foo', 'some value1')
-      described_class.store(:bar, 'bar', 'some value2')
-      described_class.store(:baz, 'baz', 'some value3')
-    end
-    context 'when default argument' do
-      before { described_class.clear_all_ns }
-      it { expect(described_class.data).to eq(cloud: { status: false }, foo: {}, bar: {}, baz: {}) }
-    end
-    context 'when custom argument' do
-      let(:exception_list) { %i[foo bar] }
-      before { described_class.clear_all_ns(exception_list) }
-      it do
-        expect(described_class.data).to eq(
-          cloud: {},
-          foo: { 'foo' => 'some value1' },
-          bar: { 'bar' => 'some value2' },
-          baz: {}
-        )
-      end
-    end
-  end
-end