contentful_middleman 1.1.1 → 1.2.0

data/spec/contentful_middleman/helpers_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+class HelpersMock
+  include ContentfulMiddleman::Helpers
+end
+
+class InstanceDouble
+end
+
+describe ContentfulMiddleman::Helpers do
+  let(:entry) do
+    {
+      value_field: {
+        'es' => 'foo',
+        'en-US' => 'bar'
+      },
+      array_field: [
+        {
+          'es' => 'foobar',
+          'en-US' => 'baz'
+        }
+      ]
+    }
+  end
+
+  subject { HelpersMock.new }
+
+  before(:each) do
+    ContentfulMiddleman.instance_variable_set(:@contentful_middleman_instances, [])
+  end
+
+
+  describe 'instance methods' do
+    describe '#contentful_instances' do
+      it 'default - is an empty array' do
+        expect(subject.contentful_instances).to eq([])
+      end
+
+      it 'returns multiple instances' do
+        ContentfulMiddleman.instances << InstanceDouble.new
+        ContentfulMiddleman.instances << InstanceDouble.new
+
+        expect(subject.contentful_instances.size).to eq(2)
+      end
+    end
+
+    describe 'localization helpers' do
+      describe '#localize_value' do
+        it 'returns value if not a hash independently of locale' do
+          expect(subject.localize_value('foo', 'es')).to eq('foo')
+        end
+
+        describe 'value is a hash' do
+          it 'returns fallback_locale value if locale not found' do
+            expect(subject.localize_value({'en-US' => 'foo'}, 'es')).to eq('foo')
+            expect(subject.localize_value({'de-DE' => 'bar'}, 'es', 'de-DE')).to eq('bar')
+          end
+
+          it 'returns localized value if locale found' do
+            expect(subject.localize_value({'es' => 'foobar'}, 'es')).to eq('foobar')
+          end
+
+          it 'fails if locale or fallback_locale not found' do
+            expect { subject.localize_value({'de-DE' => 'baz'}, 'es') }.to raise_error KeyError
+          end
+        end
+      end
+
+      describe '#localize_array' do
+        it 'calls #localize_value for every element in the array' do
+          expect(subject).to receive(:localize_value).with({'es' => 'foo'}, 'es', 'en-US')
+
+          subject.localize_array([{'es' => 'foo'}], 'es')
+        end
+      end
+
+      describe '#localize' do
+        it 'calls #localize_value for a value field' do
+          expect(subject).to receive(:localize_value).with({'es' => 'foo', 'en-US' => 'bar'}, 'es', 'en-US').and_call_original
+
+          expect(subject.localize(entry, :value_field, 'es')).to eq('foo')
+        end
+
+        it 'calls #localize_array for an array field' do
+          expect(subject).to receive(:localize_array).with([{'es' => 'foobar', 'en-US' => 'baz'}], 'es', 'en-US').and_call_original
+
+          expect(subject.localize(entry, :array_field, 'es')).to eq(['foobar'])
+        end
+      end
+
+      it '#localize_entry' do
+        expect(subject.localize_entry(entry, 'es')).to eq({
+          value_field: 'foo',
+          array_field: ['foobar']
+        })
+      end
+    end
+  end
+end

data/spec/contentful_middleman/import_task_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+class ClientDouble
+  def entries
+    []
+  end
+end
+
+describe ContentfulMiddleman::ImportTask do
+  let(:path) { File.expand_path(File.join(File.dirname(__FILE__), '..', 'fixtures', 'space_hash_fixtures')) }
+  subject { described_class.new 'foobar', {}, {}, ClientDouble.new }
+
+  describe 'instance methods' do
+    before do
+        ContentfulMiddleman::VersionHash.source_root = path
+    end
+
+    describe '#run' do
+      it 'doesnt change when data did not change' do
+        expect_any_instance_of(ContentfulMiddleman::LocalData::Store).to receive(:write)
+
+        subject.run
+        expect(subject.changed_local_data?).to eq(false)
+      end
+
+      it 'changes when data is new' do
+        subject = described_class.new 'blah', {}, {}, ClientDouble.new
+
+        if ::File.exist?(::File.join(path, '.blah-space-hash'))
+          ::File.delete(::File.join(path, '.blah-space-hash'))
+        end
+
+        expect_any_instance_of(ContentfulMiddleman::LocalData::Store).to receive(:write)
+
+        subject.run
+
+        expect(subject.changed_local_data?).to eq(true)
+      end
+    end
+  end
+end

data/spec/contentful_middleman/instance_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+class ExtensionDouble
+  attr_reader :options
+  def initialize(options = OptionsDouble.new)
+    @options = options
+  end
+end
+
+class MapperDouble
+end
+
+describe ContentfulMiddleman::Instance do
+  let(:extension) { ExtensionDouble.new }
+  let(:options) { extension.options }
+  subject { described_class.new(extension) }
+
+  describe 'instance methods' do
+    describe '#entries' do
+      it 'gets entries from API' do
+        vcr('instance/entries_1') {
+          client = subject.send(:client)
+
+          expect(client).to receive(:entries).with(options.cda_query)
+
+          subject.entries
+        }
+      end
+
+      it 'all_entries' do
+        vcr('instance/entries_2') {
+          allow(options).to receive(:all_entries) { true }
+          client = subject.send(:client)
+
+          expect(client).to receive(:entries).with(limit: 1).and_call_original
+          expect(client).to receive(:entries).with(options.cda_query.merge(limit: 1000, skip: 0, order: 'sys.createdAt')).and_call_original
+
+          subject.entries
+        }
+      end
+    end
+
+    it '#space_name' do
+      expect(subject.space_name).to eq('cats')
+    end
+
+    describe '#content_types_ids_to_mappers' do
+      it 'returns an empty hash if none set' do
+        expect(subject.content_types_ids_to_mappers).to eq({})
+      end
+
+      it 'returns a hash of ct_id => mapper' do
+        allow(options).to receive(:content_types) { {an_id: {mapper: MapperDouble}} }
+
+        expect(subject.content_types_ids_to_mappers).to eq({an_id: MapperDouble})
+      end
+    end
+
+    describe '#content_types_ids_to_names' do
+      it 'returns an empty hash if none set' do
+        expect(subject.content_types_ids_to_names).to eq({})
+      end
+
+      it 'returns a hash of ct_id => name' do
+        allow(options).to receive(:content_types) { {an_id: {name: 'foo'}} }
+
+        expect(subject.content_types_ids_to_names).to eq({an_id: 'foo'})
+      end
+    end
+  end
+end

data/spec/contentful_middleman/local_data/file_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class ThorDouble
+  def create_file(path, *args, &block)
+  end
+end
+
+describe ContentfulMiddleman::LocalData::File do
+  describe 'class methods' do
+    it '::thor= / ::thor' do
+      expect(described_class.thor).to eq nil
+
+      described_class.thor = 'foo'
+
+      expect(described_class.thor).to eq 'foo'
+    end
+  end
+
+  describe 'instance methods' do
+    let(:thor) { ThorDouble.new }
+    subject { described_class.new 'foo', 'bar' }
+
+    before do
+      ContentfulMiddleman::LocalData::Store.base_path = 'foo'
+      described_class.thor = thor
+    end
+
+    it '#write' do
+      expect(thor).to receive(:create_file).with(::File.join('foo', 'bar.yaml'), nil, {})
+
+      subject.write
+    end
+  end
+end

data/spec/contentful_middleman/local_data/store_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+class FileDouble
+  def write
+  end
+end
+
+describe ContentfulMiddleman::LocalData::Store do
+  let(:path) { File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'backup_fixtures')) }
+
+  before do
+    described_class.base_path = nil
+  end
+
+  describe 'class methods' do
+    it '::base_path / ::base_path=' do
+      expect(described_class.base_path).to eq nil
+
+      described_class.base_path = 'foo'
+
+      expect(described_class.base_path).to eq 'foo'
+    end
+  end
+
+  describe 'instance methods' do
+    before do
+      described_class.base_path = 'foo'
+    end
+
+    let(:file) { FileDouble.new }
+    subject { described_class.new [file], path }
+
+    describe '#write' do
+      it 'writes with backup' do
+        expect(subject).to receive(:do_with_backup)
+
+        subject.write
+      end
+
+      it 'calls write on every file object' do
+        expect(file).to receive(:write)
+
+        subject.write
+      end
+    end
+  end
+end

data/spec/contentful_middleman/mappers/base_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe ContentfulMiddleman::Mapper::Base do
+  let(:entries) do
+    vcr('mappers/entries') {
+      client = Contentful::Client.new(
+        access_token: 'b4c0n73n7fu1',
+        space: 'cfexampleapi',
+        dynamic_entries: :auto
+      )
+
+      client.entries
+    }
+  end
+
+  let(:entries_localized) do
+    vcr('mappers/entries_localized') {
+      client = Contentful::Client.new(
+        access_token: 'b4c0n73n7fu1',
+        space: 'cfexampleapi',
+        dynamic_entries: :auto
+      )
+
+      client.entries(locale: '*', include: 1)
+    }
+  end
+
+  let(:options) { OptionsDouble.new }
+  subject { described_class.new entries, options }
+
+  describe 'instance methods' do
+    let(:context) { ContentfulMiddleman::Context.new }
+
+    describe '#map' do
+      it 'maps entries without multiple locales' do
+        expect(context.hashize).to eq({})
+
+        expected = {
+          :id=>"6KntaYXaHSyIw8M6eo26OK",
+          :name=>"Doge",
+          :image=> {
+            :title=>"Doge",
+            :url=> "//images.contentful.com/cfexampleapi/1x0xpXu4pSGS4OukSyWGUK/cc1239c6385428ef26f4180190532818/doge.jpg"
+          },
+          :description=>"such json\nwow"
+        }
+
+        subject.map(context, entries.first)
+
+        expect(context.hashize).to eq(expected)
+      end
+
+      it 'maps entries with multiple locales' do
+        subject = described_class.new entries, OptionsDouble.new(cda_query: {locale: '*'})
+        expect(context.hashize).to eq({})
+
+        expected = {
+          :id=>"6KntaYXaHSyIw8M6eo26OK",
+          :name=> {
+            :'en-US'=>"Doge"
+          },
+          :image=>{
+            :'en-US'=>{
+              "sys"=>{
+                "type"=>"Link",
+                "linkType"=>"Asset",
+                "id"=>"1x0xpXu4pSGS4OukSyWGUK"
+              }
+            }
+          },
+          :description=>{
+            :'en-US'=>"such json\nwow"
+          }
+        }
+
+        subject.map(context, entries_localized.first)
+
+        expect(context.hashize).to eq(expected)
+      end
+    end
+  end
+
+  describe 'attributes' do
+    it ':entries' do
+      expect(subject.entries).to match(entries)
+    end
+  end
+end

data/spec/contentful_middleman/tools/backup_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+class DoBackupDouble
+  include ContentfulMiddleman::Tools::Backup::InstanceMethods
+end
+
+describe ContentfulMiddleman::Tools::NullBackup do
+  describe 'instance methods' do
+    describe 'do nothing' do
+      it '#restore' do
+        expect(subject.restore).to eq nil
+      end
+
+      it '#destroy' do
+        expect(subject.destroy).to eq nil
+      end
+    end
+  end
+end
+
+describe ContentfulMiddleman::Tools::Backup do
+  let(:path) { File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'backup_fixtures')) }
+  subject { described_class.new('foo', 'foo_source') }
+
+  before do
+    ENV['MM_ROOT'] = path
+  end
+
+  describe 'class methods' do
+    it '::basepath' do
+      expect(described_class.basepath).to eq File.join(path, '.tmp', 'backups')
+    end
+
+    describe '::ensure_backup_path!' do
+      it 'does nothing if ::basepath exists' do
+        expect(FileUtils).not_to receive(:mkdir_p)
+
+        described_class.ensure_backup_path!
+      end
+
+      it 'creates basepath directory if it doesnt exist' do
+        expect(FileUtils).to receive(:mkdir_p).with(described_class.basepath).and_call_original
+
+        FileUtils.rm_rf(described_class.basepath)
+
+        expect(::File.exist?(described_class.basepath)).to be_falsey
+
+        described_class.ensure_backup_path!
+
+        expect(::File.exist?(described_class.basepath)).to be_truthy
+      end
+    end
+  end
+
+  describe 'instance methods' do
+    before do
+      # Initialize calls this
+      allow(FileUtils).to receive(:mkdir)
+      allow(FileUtils).to receive(:mv)
+    end
+
+    it '#restore' do
+      expect(FileUtils).to receive(:rm_rf).with('foo_source')
+      expect(FileUtils).to receive(:mv).with(/foo-/, 'foo_source')
+
+      subject.restore
+    end
+
+    it '#destroy' do
+      expect(FileUtils).to receive(:rm_rf).with(/foo-/)
+
+      subject.destroy
+    end
+  end
+end
+
+describe DoBackupDouble do
+  let(:path) { File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'backup_fixtures')) }
+
+  before do
+    ENV['MM_ROOT'] = path
+
+    # Backup::Initialize calls this
+    allow(FileUtils).to receive(:mkdir)
+    allow(FileUtils).to receive(:mv)
+  end
+
+  describe 'ContentfulMiddleman::Tools::Backup::InstanceMethods' do
+    describe 'instance methods' do
+      describe '#do_with_backup' do
+        it 'when invalid path, uses a NullBackup and does nothing' do
+          expect(ContentfulMiddleman::Tools::NullBackup).to receive(:new).and_call_original
+          expect_any_instance_of(ContentfulMiddleman::Tools::NullBackup).to receive(:destroy)
+          subject.do_with_backup('bar', 'baz') { }
+        end
+
+        it 'when valid path' do
+          expect(ContentfulMiddleman::Tools::Backup).to receive(:new).with('foo', File.join(path, 'baz')).and_call_original
+          expect_any_instance_of(ContentfulMiddleman::Tools::Backup).to receive(:destroy)
+          subject.do_with_backup('foo', File.join(path, 'baz')) { }
+        end
+
+        it 'when error thrown on block, it calls restore' do
+          expect(ContentfulMiddleman::Tools::Backup).to receive(:new).with('foo', File.join(path, 'baz')).and_call_original
+          expect_any_instance_of(ContentfulMiddleman::Tools::Backup).to receive(:restore)
+          expect_any_instance_of(ContentfulMiddleman::Tools::Backup).to receive(:destroy)
+
+          expect { subject.do_with_backup('foo', File.join(path, 'baz')) { raise 'some_error' } }.to raise_error 'some_error'
+        end
+      end
+    end
+  end
+end

data/spec/contentful_middleman/version_hash_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+class EntryDouble
+  attr_reader :id, :updated_at
+
+  def initialize(id, updated_at)
+    @id = id
+    @updated_at = updated_at
+  end
+end
+
+describe ContentfulMiddleman::VersionHash do
+  let(:path) { File.expand_path(File.join(File.dirname(__FILE__), '..', 'fixtures', 'space_hash_fixtures')) }
+  describe 'class methods' do
+    it '::source_root=' do
+      described_class.source_root = 'foobar'
+      expect(described_class.instance_variable_get(:@source_root)).to eq('foobar')
+    end
+
+    describe '::read_for_space' do
+      before do
+        described_class.source_root = path
+      end
+
+      it 'unhashed space returns nil' do
+        expect(described_class.read_for_space('i_dont_exist')).to eq(nil)
+      end
+
+      it 'hashed space returns hash' do
+        expect(described_class.read_for_space('foo').chomp).to eq('bar')
+      end
+    end
+
+    describe '::write_for_space_with_entries' do
+      let(:entries) { [EntryDouble.new(1, '2015-11-25'), EntryDouble.new(2, '2015-11-25')] }
+
+      before do
+        described_class.source_root = path
+      end
+
+      it 'hashes entries and saves them on a file' do
+        allow(::File).to receive(:open).with(File.join(path, '.my_space-space-hash'), 'w')
+        expect(Digest::SHA1).to receive(:hexdigest)
+
+        described_class.write_for_space_with_entries('my_space', entries)
+      end
+
+      it 'matches hash on next read' do
+        sorted_entries = entries.sort { |a, b| a.id <=> b.id }
+        hash = Digest::SHA1.hexdigest(sorted_entries.map { |e| "#{e.id}#{e.updated_at}" }.join)
+
+        described_class.write_for_space_with_entries('my_space', entries)
+
+        expect(described_class.read_for_space('my_space')).to eq(hash)
+      end
+    end
+  end
+end

data/spec/contentful_middleman/webhook_handler_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+class ContentfulMiddleman::WebhookHandler
+  def sleep(*)
+    nil
+  end
+
+  def system(*)
+    nil
+  end
+end
+
+describe ContentfulMiddleman::WebhookHandler do
+  subject { described_class.new ServerDouble.new, Logger.new(STDOUT), 10 }
+
+  describe 'class methods' do
+    it '::start' do
+      expect(Contentful::Webhook::Listener::Server).to receive(:start)
+
+      described_class.start webhook_timeout: 10
+    end
+  end
+
+  describe 'instance methods' do
+    it '#perform' do
+      expect(subject.logger).to receive(:info).twice
+      expect(subject).to receive(:sleep).with(10)
+      expect(subject).to receive(:system).with('bundle exec middleman contentful --rebuild')
+      subject.perform(RequestDouble.new, ResponseDouble.new)
+    end
+  end
+end

data/spec/fixtures/space_hash_fixtures/.blah-space-hash

@@ -0,0 +1 @@
+da39a3ee5e6b4b0d3255bfef95601890afd80709

data/spec/fixtures/space_hash_fixtures/.foo-space-hash

@@ -0,0 +1 @@
+bar

data/spec/fixtures/space_hash_fixtures/.foobar-space-hash

@@ -0,0 +1 @@
+da39a3ee5e6b4b0d3255bfef95601890afd80709

data/spec/fixtures/space_hash_fixtures/.my_space-space-hash

@@ -0,0 +1 @@
+bb12d7986a7a821a9d1ede65bc8ce73a1dc6678c