middleman-dato 0.0.1.rc12 → 0.5.0

data/spec/dato/field_type/seo_spec.rb

@@ -0,0 +1,31 @@
+module Dato
+  module FieldType
+    RSpec.describe Seo do
+      subject(:seo) { described_class.parse(attributes, nil) }
+      let(:attributes) do
+        {
+          title: 'title',
+          description: 'description',
+          image: {
+            path: '/foo.png',
+            format: 'jpg',
+            size: 4000,
+            width: 20,
+            height: 20
+          }
+        }
+      end
+
+      it 'responds to title, description and image methods' do
+        expect(seo.title).to eq 'title'
+        expect(seo.description).to eq 'description'
+        expect(seo.image).to be_a Dato::FieldType::Image
+        expect(seo.image.path).to eq '/foo.png'
+        expect(seo.image.format).to eq 'jpg'
+        expect(seo.image.size).to eq 4000
+        expect(seo.image.width).to eq 20
+        expect(seo.image.height).to eq 20
+      end
+    end
+  end
+end

data/spec/dato/field_type/video_spec.rb

@@ -0,0 +1,32 @@
+module Dato
+  module FieldType
+    RSpec.describe Video do
+      subject(:video) { described_class.parse(attributes, nil) }
+      let(:attributes) do
+        {
+          url: 'https://www.youtube.com/watch?v=oHg5SJYRHA0',
+          provider_url: 'https://www.youtube.com',
+          thumbnail_url: 'http://i3.ytimg.com/vi/oHg5SJYRHA0/hqdefault.jpg',
+          title: "RickRoll'D",
+          width: 640,
+          height: 480
+        }
+      end
+
+      it 'responds to path, format, size, width and height' do
+        expect(video.url).to eq 'https://www.youtube.com/watch?v=oHg5SJYRHA0'
+        expect(video.provider_url).to eq 'https://www.youtube.com'
+        expect(video.thumbnail_url).to eq 'http://i3.ytimg.com/vi/oHg5SJYRHA0/hqdefault.jpg'
+        expect(video.title).to eq "RickRoll'D"
+        expect(video.width).to eq 640
+        expect(video.height).to eq 480
+      end
+
+      describe 'iframe_embed' do
+        it 'returns a iframe embed HTML fragment' do
+          expect(video.iframe_embed).to eq '<iframe width="560" height="315" src="http://www.youtube.com/embed/oHg5SJYRHA0?rel=0" frameborder="0" allowfullscreen></iframe>'
+        end
+      end
+    end
+  end
+end

data/spec/dato/json_api_entity_spec.rb

@@ -0,0 +1,123 @@
+require 'dato/json_api_entity'
+
+module Dato
+  RSpec.describe JsonApiEntity do
+    subject(:object) { described_class.new(payload, data_source) }
+    let(:payload) do
+      {
+        id: 'peter',
+        type: 'person',
+        attributes: {
+          first_name: 'Peter',
+          last_name: 'Griffin'
+        },
+        relationships: {
+          children: {
+            data: [
+              { type: 'person', id: 'stewie' }
+            ]
+          },
+          mother: {
+            data: { type: 'person', id: 'thelma' }
+          }
+        }
+      }
+    end
+
+    let(:data_source) do
+      instance_double('Dato::DataSource')
+    end
+
+    describe '#id' do
+      it 'returns the object ID' do
+        expect(object.id).to eq 'peter'
+      end
+    end
+
+    describe '#type' do
+      it 'returns the object type' do
+        expect(object.type).to eq 'person'
+      end
+    end
+
+    describe 'attributes' do
+      it 'returns the attribute if it exists' do
+        expect(object.respond_to?(:first_name)).to be_truthy
+        expect(object.first_name).to eq 'Peter'
+      end
+
+      it 'returns NoMethodError if it doesnt' do
+        expect(object.respond_to?(:foo_bar)).to be_falsy
+        expect { object.foo_bar }.to raise_error NoMethodError
+      end
+    end
+
+    describe '[]' do
+      it 'returns the attribute if it exists' do
+        expect(object[:first_name]).to eq 'Peter'
+      end
+
+      it 'returns nil if it doesnt' do
+        expect(object[:foo_bar]).to be_nil
+      end
+    end
+
+    describe '==' do
+      context 'same id and type' do
+        let(:other) do
+          described_class.new({ id: 'peter', type: 'person' }, data_source)
+        end
+
+        it 'returns true' do
+          expect(object == other).to be_truthy
+        end
+      end
+
+      context 'different id and type' do
+        let(:other) do
+          described_class.new({ id: 'stewie', type: 'person' }, data_source)
+        end
+
+        it 'returns false' do
+          expect(object == other).to be_falsy
+        end
+      end
+
+      context 'different class' do
+        let(:other) do
+          12
+        end
+
+        it 'returns false' do
+          expect(object == other).to be_falsy
+        end
+      end
+    end
+
+    describe 'links' do
+      let(:stewie) { instance_double('Dato::JsonApiObject') }
+      let(:thelma) { instance_double('Dato::JsonApiObject') }
+
+      before do
+        allow(data_source).to receive(:find_entity).with('person', 'stewie') { stewie }
+        allow(data_source).to receive(:find_entity).with('person', 'thelma') { thelma }
+      end
+
+      context 'multiple linkages' do
+        it 'returns the array of JsonApiObjects' do
+          expect(object.children).to eq [stewie]
+        end
+      end
+
+      context 'single linkage' do
+        it 'returns the JsonApiObject' do
+          expect(object.mother).to eq thelma
+        end
+      end
+
+      it 'returns NoMethodError if it does not exist' do
+        expect { object.father }.to raise_error NoMethodError
+      end
+    end
+  end
+end

data/spec/dato/meta_tags/article_modified_time_spec.rb

@@ -1,19 +1,21 @@
-require "spec_helper"
+require 'spec_helper'
 
-module Dato::MetaTags
-  RSpec.describe ArticleModifiedTime do
-    subject(:meta_tag) { described_class.new(builder, base_url, space, record) }
-    let(:builder) { MockBuilder.new }
-    let(:base_url) { nil }
-    let(:space) { nil }
-    let(:record) do
-      double("Record", updated_at: Time.now, singleton?: false)
-    end
+module Dato
+  module MetaTags
+    RSpec.describe ArticleModifiedTime do
+      subject(:meta_tag) { described_class.new(builder, base_url, space, record) }
+      let(:builder) { ::MockBuilder.new }
+      let(:base_url) { nil }
+      let(:space) { nil }
+      let(:record) do
+        double('Record', updated_at: Time.now, singleton?: false)
+      end
 
-    describe ".value" do
-      context "if record is not singleton" do
-        it "returns an ISO 8601 time representation" do
-          expect(meta_tag.value).not_to be_nil
+      describe '.value' do
+        context 'if record is not singleton' do
+          it 'returns an ISO 8601 time representation' do
+            expect(meta_tag.value).not_to be_nil
+          end
         end
       end
     end

data/spec/dato/meta_tags/image_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Dato
+  module MetaTags
+    RSpec.describe Image do
+      subject(:meta_tag) { described_class.new(builder, base_url, space, record) }
+      let(:builder) { ::MockBuilder.new }
+      let(:base_url) { nil }
+      let(:space) { nil }
+      let(:record) do
+        double(
+          'Dato::Record',
+          fields: [double('Dato::JsonApiEntity', api_key: 'foo', field_type: 'image')],
+          foo: image,
+          singleton?: false
+        )
+      end
+
+      let(:field) do
+        { field_type: 'image' }
+      end
+
+      let(:image) do
+        double(
+          'Dato::JsonApiEntity',
+          width: 300,
+          height: 300,
+          file: double('File', format: double('Imgix', to_url: 'http://google.com'))
+        )
+      end
+
+      describe '.value' do
+        it 'returns the current locale' do
+          expect(meta_tag.image).to eq 'http://google.com'
+        end
+      end
+    end
+  end
+end

data/spec/dato/meta_tags/og_locale_spec.rb

@@ -1,17 +1,19 @@
-require "spec_helper"
+require 'spec_helper'
 
-module Dato::MetaTags
-  RSpec.describe OgLocale do
-    subject(:meta_tag) { described_class.new(builder, base_url, space, record) }
-    let(:builder) { MockBuilder.new }
-    let(:base_url) { nil }
-    let(:space) { nil }
-    let(:record) { nil }
+module Dato
+  module MetaTags
+    RSpec.describe OgLocale do
+      subject(:meta_tag) { described_class.new(builder, base_url, space, record) }
+      let(:builder) { ::MockBuilder.new }
+      let(:base_url) { nil }
+      let(:space) { nil }
+      let(:record) { nil }
 
-    describe ".value" do
-      it "returns the current locale" do
-        I18n.with_locale(:it) do
-          expect(meta_tag.value).to eq "it_IT"
+      describe '#value' do
+        it 'returns the current locale' do
+          I18n.with_locale(:it) do
+            expect(meta_tag.value).to eq 'it_IT'
+          end
         end
       end
     end

data/spec/dato/record_spec.rb

@@ -1,103 +1,162 @@
-require "spec_helper"
-
-RSpec.describe Dato::Record do
-  subject(:record) { described_class.new(attributes, content_type) }
-  let(:attributes) { {} }
-  let(:content_type) { { fields: {} } }
-
-  it "gets attributes and content type as constructor parameters" do
-    record
-  end
-
-  describe "#singleton?" do
-    context "if the record is a singleton" do
-      let(:content_type) { { fields: {}, singleton: true } }
-
-      it "returns true" do
-        expect(record.singleton?).to eq(true)
-      end
+module Dato
+  RSpec.describe Record do
+    subject(:record) { described_class.new(entity, repo) }
+    let(:entity) do
+      double(
+        'Dato::JsonApiEntity(Record)',
+        id: '14',
+        content_type: content_type,
+        title: "My titlè with àccents",
+        body: 'Hi there',
+        position: 2,
+        updated_at: '2010-01-01T00:00'
+      )
+    end
+    let(:repo) do
+      instance_double('Dato::RecordsRepo')
+    end
+    let(:content_type) do
+      double(
+        'Dato::JsonApiEntity(Content Type)',
+        singleton: is_singleton,
+        api_key: 'work_item',
+        fields: fields
+      )
+    end
+    let(:is_singleton) { false }
+    let(:fields) do
+      [
+        double(
+          'Dato::JsonApiEntity(Field)',
+          position: 1,
+          api_key: 'title',
+          localized: false,
+          field_type: 'string',
+          appeareance: { type: 'title' }
+        ),
+        double(
+          'Dato::JsonApiEntity(Field)',
+          position: 1,
+          api_key: 'body',
+          localized: false,
+          field_type: 'text',
+          appeareance: { type: 'plain' }
+        )
+      ]
     end
 
-    context "else" do
-      let(:content_type) { { fields: {}, singleton: false } }
+    describe '#slug' do
+      context 'singleton' do
+        let(:is_singleton) { true }
 
-      it "returns false" do
-        expect(record.singleton?).to eq(false)
+        it 'returns the parameterized content type api key' do
+          expect(record.slug).to eq 'work-item'
+        end
       end
-    end
-  end
 
-  describe "#respond_to?" do
-    let(:attributes) { { foo: "bar" } }
+      context 'non singleton, no title field' do
+        let(:fields) { [] }
 
-    context "if the record contains the requested field" do
-      it "returns true" do
-        expect(record.respond_to?(:foo)).to eq(true)
+        it 'returns the ID' do
+          expect(record.slug).to eq '14'
+        end
       end
-    end
 
-    context "else" do
-      it "returns true" do
-        expect(record.respond_to?(:bar)).to eq(false)
+      context 'non singleton, title field' do
+        it 'returns the ID + title' do
+          expect(record.slug).to eq '14-my-title-with-accents'
+        end
       end
     end
-  end
-
-  describe "#id" do
-    let(:attributes) { { id: 123 } }
 
-    it "returns the id of the record" do
-      expect(record.id).to eq(123)
-    end
-  end
-
-  describe "#updated_at" do
-    let(:attributes) { { updated_at: "2015-06-09T12:47" } }
-
-    it "parses the field and returns a Time object" do
-      expect(record.updated_at).to eq(Time.new(2015, 6, 9, 12, 47))
-    end
-  end
-
-  describe "#slug" do
-    let(:attributes) { { id: 1, title: "Foo Bar" } }
-
-    context 'if there is a "title" field' do
-      let(:content_type) { { fields: { title: { field_type: "title" } } } }
-
-      it "retuns the slug of the record" do
-        expect(record.slug).to eq("1-foo-bar")
+    describe '#attributes' do
+      it 'returns an hash of the field values' do
+        expected_attributes = { title: "My titlè with àccents", body: 'Hi there' }
+        expect(record.attributes).to eq expected_attributes
       end
     end
 
-    context "else" do
-      let(:content_type) { { fields: { title: { field_type: "text" } } } }
-
-      it "returns nil" do
-        expect(record.slug).to be_nil
+    describe 'position' do
+      it 'returns the entity position field' do
+        expect(record.position).to eq 2
       end
     end
-  end
-
-  describe "#method_missing" do
-    let(:content_type) { { fields: { foo: { field_type: "text" } } } }
-    let(:attributes) { { foo: "bar" } }
 
-    before do
-      allow(Dato::Field).to receive(:value).and_return("bar")
+    describe 'updated_at' do
+      it 'returns the entity updated_at field' do
+        expect(record.updated_at).to be_a Time
+      end
     end
 
-    context "if the requested method matches one attribute" do
-      before { record.foo }
+    describe 'dynamic methods' do
+      context 'existing field' do
+        it 'returns the field value' do
+          expect(record.respond_to?(:body)).to be_truthy
+          expect(record.body).to eq 'Hi there'
+        end
+
+        context 'localized field' do
+          let(:entity) do
+            double(
+              'Dato::JsonApiEntity(Record)',
+              id: '14',
+              content_type: content_type,
+              title: { it: 'Foo', en: 'Bar' }
+            )
+          end
+
+          let(:fields) do
+            [
+              double(
+                'Dato::JsonApiEntity(Field)',
+                position: 1,
+                api_key: 'title',
+                localized: true,
+                field_type: 'string',
+                appeareance: { type: 'plain' }
+              )
+            ]
+          end
+
+          it 'returns the value for the current locale' do
+            I18n.with_locale(:it) do
+              expect(record.title).to eq 'Foo'
+            end
+          end
+
+          context 'non existing value' do
+            it 'raises nil' do
+              I18n.with_locale(:ru) do
+                expect(record.title).to eq nil
+              end
+            end
+          end
+        end
+      end
 
-      it 'calls the ".value" method of "Field" class' do
-        expect(Dato::Field).to have_received(:value).with(attributes[:foo], content_type[:fields][:foo])
+      context 'non existing field' do
+        it 'raises NoMethodError' do
+          expect(record.respond_to?(:qux)).to be_falsy
+          expect { record.qux }.to raise_error NoMethodError
+        end
       end
-    end
 
-    context "if the same attribute is requested multiple times" do
-      it "returns the same object" do
-        expect(record.foo.object_id).to eq(record.foo.object_id)
+      context 'non existing field type' do
+        let(:fields) do
+          [
+            double(
+              'Dato::JsonApiEntity(Field)',
+              position: 1,
+              api_key: 'title',
+              localized: true,
+              field_type: 'rotfl'
+            )
+          ]
+        end
+
+        it 'raises RuntimeError' do
+          expect { record.title }.to raise_error RuntimeError
+        end
       end
     end
   end