contentful_model 0.2.0 → 1.0.0

data/spec/manageable_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+class InvalidSaveCat < ContentfulModel::Base
+  self.content_type_id = 'cat'
+
+  validate :always_fail, -> (e) { false }
+end
+
+describe ContentfulModel::Manageable do
+  before :each do
+    ContentfulModel.configure do |c|
+      c.default_locale = 'en-US'
+      c.management_token = '<ACCESS_TOKEN>'
+      c.access_token = '4d0f55d940975f78139daae5d965b463c0816e88ad16062d2c1ee3d6cb930521'
+      c.space = 'facgnwwgj5fe'
+      c.entry_mapping = {}
+    end
+
+    InvalidSaveCat.client = nil
+    Cat.client = nil
+  end
+
+  let(:space_id) { 'facgnwwgj5fe' }
+  let(:entry_id) { 'IJLRrADsqq2AmwcugoYeK' }
+  subject { vcr('playground/nyancat') { Cat.find(entry_id) } }
+
+  describe 'class methods' do
+    it '::management' do
+      expect(Cat.management).to be_a(ContentfulModel::Management)
+    end
+
+    describe '::create' do
+      before do
+        @mock_client = Object.new
+        @mock_ct = Object.new
+        @mock_entry = Object.new
+        allow(Cat).to receive(:management) { @mock_client }
+        allow(@mock_client).to receive(:entries) { @mock_client }
+        allow(@mock_client).to receive(:content_types) { @mock_client }
+        allow(@mock_client).to receive(:find).with('cat') { @mock_ct }
+        @values = {'name' => 'Nyan Cat'}
+      end
+
+      it 'creates an entry' do
+        expect(@mock_client).to receive(:create).with(@mock_ct, @values) { @mock_entry }
+
+        Cat.create(@values)
+      end
+
+      it 'publishes after creation' do
+        allow(@mock_client).to receive(:create).with(@mock_ct, @values) { @mock_entry }
+        allow(@mock_entry).to receive(:id) { entry_id }
+        allow(Cat).to receive(:find).with(entry_id) { @mock_entry }
+        expect(@mock_entry).to receive(:publish)
+
+        Cat.create(@values, true)
+      end
+    end
+  end
+
+  describe 'instance methods' do
+    it '#to_management' do
+      vcr('management/client') {
+        expect(subject.to_management).to be_a(Contentful::Management::Entry)
+        expect(subject.to_management.id).to eq(entry_id)
+      }
+    end
+
+    it 'creates setters for fields' do
+      expect(subject.respond_to?(:name=)).to be_truthy
+    end
+
+    it 'allows to override values' do
+      expect(subject.name).to eq('Nyan Cat')
+      subject.name = 'Fat Cat'
+      expect(subject.name).to eq('Fat Cat')
+    end
+
+    context 'modifying the space' do
+      describe '#save' do
+        it 'fails on invalid instance' do
+          vcr('management/nyancat') {
+            subject = InvalidSaveCat.find(entry_id)
+
+            expect(subject).not_to receive(:to_management)
+
+            expect(subject.save).to be_falsey
+
+            expect(subject.errors).to match_array [
+              'always_fail: validation not met'
+            ]
+          }
+        end
+
+        it 'calls #save on management object' do
+          vcr('management/nyancat') {
+            subject = Cat.find(entry_id)
+
+            version = subject.to_management.sys[:version]
+
+            expect(subject.name).to eq 'Nyan Cat'
+
+            subject.name = 'Fat Cat'
+            vcr('management/nyancat_save') {
+              subject.save
+
+              expect(subject.to_management.sys[:version]).to eq(version + 1)
+            }
+          }
+        end
+
+        it 'sets dirty to false' do
+          vcr('management/nyancat') {
+            subject = Cat.find(entry_id)
+
+            expect(subject.dirty).to be_falsey
+
+            subject.name = 'Fat Cat'
+
+            expect(subject.dirty).to be_truthy
+            vcr('management/nyancat_save') {
+              subject.save
+
+              expect(subject.dirty).to be_falsey
+            }
+          }
+        end
+
+        it 'refetches management entry if conflict occurs' do
+          vcr('management/nyancat') {
+            subject = Cat.find(entry_id)
+
+            vcr('management/nyancat_refetch_and_save') {
+              expect(subject).to receive(:refetch_management_entry).and_call_original
+
+              subject.name = 'Foo Cat'
+              subject.save
+            }
+          }
+        end
+
+        it 'raises error if conflict happens after refetch' do
+          vcr('management/nyancat') {
+            subject = Cat.find(entry_id)
+
+            vcr('management/nyancat_refetch_and_fail') {
+              expect(subject).to receive(:refetch_management_entry).and_call_original
+
+              subject.name = 'Foo Cat'
+
+              expect { subject.save }.to raise_error ContentfulModel::VersionMismatchError
+            }
+          }
+        end
+      end
+
+      describe '#publish' do
+        it 'calls #publish on management object' do
+          vcr('management/nyancat_2') {
+            subject = Cat.find(entry_id)
+
+            version = subject.to_management.sys[:version]
+
+            expect(subject.name).to eq 'Nyan Cat'
+
+            subject.name = 'Fat Cat'
+            vcr('management/nyancat_save_2') {
+              subject.save
+
+              management_subject = subject.to_management
+              published_at = management_subject.sys[:publishedAt]
+              expect(management_subject.sys[:version]).to eq(version + 1)
+              vcr('management/nyancat_publish') {
+                subject.publish
+
+                management_subject = subject.to_management
+                expect(management_subject.sys[:version]).to eq(version + 2)
+                expect(management_subject.sys[:publishedAt]).not_to eq(published_at)
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/spec/management_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe ContentfulModel::Management do
+  before do
+    ContentfulModel.configure do |c|
+      c.management_token = 'foobar'
+    end
+  end
+
+  it 'is a Contentful::Management::Client' do
+    expect(subject).to be_a(Contentful::Management::Client)
+  end
+
+  it 'gets initialized with the configured management token' do
+    expect(subject.access_token).to eq('foobar')
+  end
+end

data/spec/migrations/content_type_factory_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe ContentfulModel::Migrations::ContentTypeFactory do
+  describe '::create' do
+    before do
+      @mock_ct = Object.new
+      allow(ContentfulModel::Migrations::ContentType).to receive(:new) { @mock_ct }
+      expect(@mock_ct).to receive(:save)
+    end
+
+    it 'saves it' do
+      described_class.create('foo')
+    end
+
+    it 'calls :field for each field sent' do
+      expect(@mock_ct).to receive(:field).with(:bar, :symbol)
+      expect(@mock_ct).to receive(:field).with(:baz, :text)
+
+      described_class.create('foo', bar: :symbol, baz: :text)
+    end
+
+    it 'yields it' do
+      expect(@mock_ct).to receive(:field).with(:bar, :symbol)
+
+      described_class.create('foo') do |ct|
+        ct.field(:bar, :symbol)
+      end
+    end
+  end
+
+  it '::find' do
+    ContentfulModel.configure { |config| config.space = 'space_id' }
+    mock_client = Object.new
+
+    allow_any_instance_of(ContentfulModel::Management).to receive(:content_types).with('space_id', 'master') { mock_client }
+    expect(mock_client).to receive(:find).with('ct_id')
+
+    result = described_class.find('ct_id')
+    expect(result).to be_a(ContentfulModel::Migrations::ContentType)
+  end
+end

data/spec/migrations/content_type_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+describe ContentfulModel::Migrations::ContentType do
+  describe 'instance methods' do
+    describe '#new?' do
+      it 'newly created returns true' do
+        expect(described_class.new.new?).to be_truthy
+      end
+
+      it 'returns true if management content type present but no id' do
+        mock_ct = Object.new
+        allow(mock_ct).to receive(:id) { nil }
+
+        expect(described_class.new(nil, mock_ct).new?).to be_truthy
+      end
+
+      it 'returns false if management content type present with id' do
+        mock_ct = Object.new
+        allow(mock_ct).to receive(:id) { 'foo' }
+
+        expect(described_class.new(nil, mock_ct).new?).to be_falsey
+      end
+    end
+
+    describe '#save' do
+      before do
+        ContentfulModel.configure do |c|
+          c.space = 'space_id'
+          c.management_token = 'token'
+        end
+      end
+
+      it 'creates a new content type on contentful' do
+        mock_client = Object.new
+        expect(mock_client).to receive(:create).with(id: 'foo', name: 'foo', fields: [])
+        allow_any_instance_of(ContentfulModel::Management).to receive(:content_types) { mock_client }
+
+        described_class.new('foo').save
+      end
+
+      it 'updates an existing content type' do
+        mock_ct = Object.new
+        allow(mock_ct).to receive(:id) { 'foo' }
+
+        expect(mock_ct).to receive(:fields=)
+        expect(mock_ct).to receive(:save)
+
+        described_class.new(nil, mock_ct).save
+      end
+    end
+
+    it '#remove_field' do
+      mock_ct = Object.new
+      mock_fields = Object.new
+
+      expect(mock_ct).to receive(:fields) { mock_fields }
+      expect(mock_fields).to receive(:destroy).with('foo')
+
+      described_class.new(nil, mock_ct).remove_field('foo')
+    end
+
+    describe '#id' do
+      it 'can set the id' do
+        subject.id = 'foo_ct'
+        expect(subject.id).to eq 'foo_ct'
+      end
+
+      it 'when saving, defined id will be used' do
+        subject.id = 'foo_ct'
+
+        expect_any_instance_of(::Contentful::Management::ClientContentTypeMethodsFactory).to receive(:create).with(
+          id: 'foo_ct',
+          name: subject.name,
+          fields: subject.fields
+        )
+
+        subject.save
+      end
+    end
+
+    describe '#field' do
+      it 'snake cases field id' do
+        field = subject.field('Foo Test', :symbol)
+
+        expect(field.id).to eq('foo_test')
+        expect(field.name).to eq('Foo Test')
+      end
+
+      it 'regular field' do
+        field = subject.field('foo', :symbol)
+
+        expect(field.id).to eq('foo')
+        expect(field.name).to eq('foo')
+        expect(field.type).to eq('Symbol')
+        expect(field.link_type).to eq(nil)
+        expect(field.items).to eq(nil)
+      end
+
+      it 'converts :string to :symbol field' do
+        field = subject.field('foo', :string)
+
+        expect(field.type).to eq('Symbol')
+      end
+
+      it 'link field' do
+        field = subject.field('foo', :entry_link)
+
+        expect(field.id).to eq('foo')
+        expect(field.name).to eq('foo')
+        expect(field.type).to eq('Link')
+        expect(field.link_type).to eq('Entry')
+        expect(field.items).to eq(nil)
+      end
+
+      it 'array field' do
+        field = subject.field('foo', :asset_array)
+
+        expect(field.id).to eq('foo')
+        expect(field.name).to eq('foo')
+        expect(field.type).to eq('Array')
+        expect(field.link_type).to eq(nil)
+
+        items = field.items
+
+        expect(items).to be_a(Contentful::Management::Field)
+        expect(items.type).to eq('Link')
+        expect(items.link_type).to eq('Asset')
+      end
+
+      it 'fails on unknown type' do
+        expect { subject.field('foo', :bar) }.to raise_error ContentfulModel::Migrations::InvalidFieldTypeError
+      end
+    end
+
+    describe '#fields' do
+      describe 'from a new content type' do
+        it 'starts empty' do
+          expect(subject.fields).to eq([])
+        end
+
+        it 'adds fields when you call :field' do
+          expect(subject.fields.size).to eq(0)
+
+          subject.field('foo', :text)
+
+          expect(subject.fields.size).to eq(1)
+          expect(subject.fields[0]).to be_a(Contentful::Management::Field)
+        end
+      end
+
+      describe 'from an existing content type' do
+        before do
+          @mock_ct = Object.new
+          allow(@mock_ct).to receive(:id) { 'foo' }
+          allow(@mock_ct).to receive(:fields) { [Contentful::Management::Field.new] }
+        end
+
+        it 'returns previously existing fields' do
+          subject = described_class.new(nil, @mock_ct)
+
+          expect(subject.fields.size).to eq(1)
+        end
+
+        it 'appends fields to existing fields' do
+          subject = described_class.new(nil, @mock_ct)
+
+          expect(subject.fields.size).to eq(1)
+
+          subject.field('foo', :text)
+
+          expect(subject.fields.size).to eq(2)
+        end
+      end
+    end
+  end
+end

data/spec/migrations/migration_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+class MockMigration
+  include ContentfulModel::Migrations::Migration
+end
+
+describe ContentfulModel::Migrations::Migration do
+  subject { MockMigration.new }
+
+  before do
+    @mock_content_type = Object.new
+    @mock_field = Object.new
+    allow(ContentfulModel::Migrations::ContentTypeFactory).to receive(:find).with('ct_id') { @mock_content_type }
+    allow(@mock_content_type).to receive(:save) { @mock_content_type }
+    allow(@mock_content_type).to receive(:publish)
+    allow(@mock_content_type).to receive(:field).with('name', :type) { @mock_field }
+    allow(@mock_content_type).to receive(:remove_field).with('name')
+  end
+
+  describe "#create_content_type" do
+    it 'creates content type' do
+      expect(ContentfulModel::Migrations::ContentTypeFactory).to receive(:create)
+
+      subject.create_content_type('foo')
+    end
+  end
+
+  describe '#add_content_type_field' do
+    it 'creates field' do
+      expect(@mock_content_type).to receive(:field)
+
+      subject.add_content_type_field('ct_id', 'name', :type)
+    end
+
+    it 'publishes content type' do
+      expect(@mock_content_type).to receive(:publish)
+
+      subject.add_content_type_field('ct_id', 'name', :type)
+    end
+
+    it 'saves content type' do
+      expect(@mock_content_type).to receive(:save)
+
+      subject.add_content_type_field('ct_id', 'name', :type)
+    end
+
+    it 'yields content type' do
+      expect(@mock_field).to receive(:validations=)
+
+      subject.add_content_type_field('ct_id', 'name', :type) do |field|
+        field.validations = []
+      end
+    end
+  end
+
+  describe '#remove_content_type_field' do
+    it 'removes field' do
+      expect(@mock_content_type).to receive(:remove_field).with('name')
+
+      subject.remove_content_type_field('ct_id', 'name')
+    end
+
+    it 'publishes content type' do
+      expect(@mock_content_type).to receive(:publish)
+
+      subject.remove_content_type_field('ct_id', 'name')
+    end
+
+    it 'saves content type' do
+      expect(@mock_content_type).to receive(:save)
+
+      subject.remove_content_type_field('ct_id', 'name')
+    end
+  end
+end