contentful_lite 1.0.2

data/lib/contentful_lite/entry.rb

@@ -0,0 +1,52 @@
+module ContentfulLite
+  class Entry
+    include CommonData
+    include EntryMapping
+    include Validations::Entry
+
+    # The id for the content type of this entry
+    attr_reader :content_type_id
+
+    # @param raw [Hash] raw response from Contentful API
+    # @api private
+    def initialize(raw)
+      super(raw)
+      @content_type_id = raw['sys']['contentType']['sys']['id']
+      @localized_fields.values.each do |fields|
+        fields.transform_values! { |value| build_link(value) }
+      end
+    end
+
+    # Gets the URL to view/edit the entry on Contentful webapp
+    # @return [String]
+    def contentful_link
+      "https://app.contentful.com/spaces/#{space_id}/entries/#{id}"
+    end
+
+    # Defines a field existing on the content type. This macro registers the
+    # accessor for that field
+    # @param attrs [Array<Symbol,String>] The field names
+    # @param default [Object, nil] The default value to return if field is not present on API response
+    # @param localizable [Boolean] If the field is marked as localizable
+    # @example Defines two string localizable localized fields
+    #   field_reader :first_name, :last_name, localizable: true
+    # @see https://github.com/JuulLabs-OSS/contentful_lite#creating-your-model-classes-with-macros
+    def self.field_reader(*attrs, default: nil, localizable: false)
+      attrs.each do |k|
+        define_method(k) do |locale: nil|
+          field = fields(locale: localizable ? locale : default_locale)[k.to_s]
+          field.nil? ? default : field
+        end
+      end
+    end
+
+    private
+
+    def build_link(value)
+      return value.map!{ |element| build_link(element) } if value.is_a?(Array)
+      return value unless value.is_a?(Hash) && value.fetch('sys', {}).fetch('type', '') == 'Link'
+
+      ContentfulLite::Link.new(value)
+    end
+  end
+end

data/lib/contentful_lite/entry_mapping.rb

@@ -0,0 +1,23 @@
+require 'active_support/concern'
+
+module ContentfulLite
+  # @api private
+  module EntryMapping
+    extend ActiveSupport::Concern
+
+    included do |base_klass|
+      base_klass.define_singleton_method(:content_type_id) do |name|
+        klass = self
+        base_klass.class_eval do
+          @mappings ||= {}
+          @mappings[name] = klass
+        end
+      end
+
+      base_klass.define_singleton_method(:get_class) do |content_type_id|
+        @mappings ||= {}
+        @mappings[content_type_id] || base_klass
+      end
+    end
+  end
+end

data/lib/contentful_lite/link.rb

@@ -0,0 +1,40 @@
+module ContentfulLite
+  # A link to any type of contentful entity
+  class Link
+    # The unique id of the linked entity
+    attr_reader :id
+    # The type of the linked entity
+    attr_reader :type
+
+    # @param input [ContentfulLite::CommonData, Hash] data to build the instance
+    # @api private
+    def initialize(input)
+      if input.is_a?(ContentfulLite::CommonData)
+        @id = input.id
+        @type = input.sys['type'].downcase.to_sym
+      else
+        @type = input['sys']['linkType'].downcase.to_sym
+        @id = input['sys']['id']
+      end
+    end
+
+    # Equality comparison
+    # @param other [Object] the object to compare
+    # @return [Boolean] true if other is ContentfulLite::Link with same id and type
+    def ==(other)
+      self.class == other.class && type == other.type && id == other.id
+    end
+
+    # Provided for compatibility with Rails JSON serializer
+    # @return [Hash] a Hash representation of the link, to be formated as JSON
+    def as_json(**)
+      {
+        'sys' => {
+          'type' => "Link",
+          'linkType' => type.to_s.capitalize,
+          'id' => id
+        }
+      }
+    end
+  end
+end

data/lib/contentful_lite/validations/entry.rb

@@ -0,0 +1,68 @@
+require 'active_support/concern'
+require 'active_model'
+require 'contentful_lite/validations/included_child_validator'
+require 'contentful_lite/validations/included_asset_validator'
+require 'contentful_lite/validations/included_entry_validator'
+
+module ContentfulLite
+  module Validations
+    module Entry
+      extend ActiveSupport::Concern
+
+      included do |base_class|
+        base_class.include(ActiveModel::Validations)
+        base_class.define_method(:errors) do |locale: nil|
+          @errors ||= Hash.new { |hash, key| hash[key] = ActiveModel::Errors.new(self) }
+          @errors[locale || self.locale]
+        end
+        base_class.define_method(:valid?) do |locale: nil|
+          with_locale(locale) { super() }
+        end
+      end
+
+      # @!method self.validates_included_entry(*attr_names, **options)
+      #   Adds a validation on one or more fields to ensure it's a reference field
+      #   and the values are entries with one of the specified types
+      #   @param attr_names [Array<string>] the fields to validate
+      #   @param options [Hash] the options Hash
+      #   @option options [Array<Class>] :allowed_models the contentful content types that will be allowed
+      #   @option options [Boolean] :allow_blank if true it allows the field to be empty
+      #   @option options [Boolean] :array if true, the field must be an array of references.
+      #     If not, it must be a single reference.
+      class_methods do
+        def validates_included_entry(*attr_names)
+          validates_with IncludedEntryValidator, _merge_attributes(attr_names)
+        end
+      end
+
+      # @!method self.validates_included_asset(*attr_names, **options)
+      #   Adds a validation on one or more fields to ensure it's a reference field
+      #   and the values are assets
+      #   @param attr_names [Array<string>] the fields to validate
+      #   @param options [Hash] the options Hash
+      #   @option options [Array<Class>] :type the asset content types that will be allowed
+      #   @option options [Boolean] :allow_blank if true it allows the field to be empty
+      #   @option options [Boolean] :array if true, the field must be an array of references.
+      #     If not, it must be a single reference.
+      class_methods do
+        def validates_included_asset(*attr_names)
+          validates_with IncludedAssetValidator, _merge_attributes(attr_names)
+        end
+      end
+
+      # Validates all locales
+      # @return [boolean] is entry valid across al locales?
+      def valid_for_all_locales?
+        locales.map do |locale|
+          valid?(locale: locale)
+        end.all?
+      end
+
+      # Gets the error messages for all the locales at once
+      # @return [Hash] a hash with locale as keys and errors as values
+      def errors_for_all_locales
+        @errors
+      end
+    end
+  end
+end

data/lib/contentful_lite/validations/included_asset_validator.rb

@@ -0,0 +1,14 @@
+module ContentfulLite
+  module Validations
+    # @api private
+    class IncludedAssetValidator < ActiveModel::EachValidator
+      include IncludedChildValidator
+      add_options_keys :type
+
+      def validate_child(record, attr_name, value, idx = nil)
+        record_error(record, attr_name, "value#{idx} is not a published asset") && return unless value.is_a?(ContentfulLite::Asset)
+        record_error(record, attr_name, "value#{idx} has an invalid asset type. Expecting #{options[:type]}") if options[:type] && !value&.content_type&.include?(options[:type].to_s)
+      end
+    end
+  end
+end

data/lib/contentful_lite/validations/included_child_validator.rb

@@ -0,0 +1,40 @@
+module ContentfulLite
+  module Validations
+    # @api private
+    module IncludedChildValidator
+      extend ActiveSupport::Concern
+      BASE_OPTIONS = %i[allow_blank array].freeze
+
+      def validate_each(record, attr_name, value)
+        if value.blank?
+          record_error(record, attr_name, "value is blank") unless options[:allow_blank]
+        elsif options[:array]
+          validate_array(record, attr_name, value)
+        else
+          validate_child(record, attr_name, value)
+        end
+      end
+
+      private
+
+      def record_error(record, attr_name, message)
+        record.errors.add(attr_name, :invalid, { message: message }.merge(options.except(self.class.options_keys)))
+      end
+
+      def validate_array(record, attr_name, value)
+        record_error(record, attr_name, "value is not an array") && return unless value.is_a?(Array)
+        value.each_with_index { |asset, idx| validate_child(record, attr_name, asset, "[#{idx}]") }
+      end
+
+      class_methods do
+        def add_options_keys(*options)
+          @options_keys = BASE_OPTIONS + options
+        end
+
+        def options_keys
+          @options_keys
+        end
+      end
+    end
+  end
+end

data/lib/contentful_lite/validations/included_entry_validator.rb

@@ -0,0 +1,24 @@
+module ContentfulLite
+  module Validations
+    # @api private
+    class IncludedEntryValidator < ActiveModel::EachValidator
+      include IncludedChildValidator
+      add_options_keys :allowed_models
+
+      def validate_child(record, attr_name, value, idx = nil)
+        unless value.is_a?(ContentfulLite::Entry)
+          record_error(record, attr_name, "value#{idx} is not a published entry")
+          return
+        end
+        record_error(record, attr_name, "value has invalid child entry #{value.id}") unless value.valid?(locale: record.locale)
+        record_error(record, attr_name, "value#{idx} has an invalid entry model. Expecting #{options[:allowed_models]}") if invalid_model?(value)
+      end
+
+      def invalid_model?(value)
+        return false unless options[:allowed_models]
+
+        options[:allowed_models]&.none?{ |type| value.is_a?(type) }
+      end
+    end
+  end
+end

data/lib/contentful_lite/version.rb

@@ -0,0 +1,3 @@
+module ContentfulLite
+  VERSION = "1.0.2".freeze
+end

data/lib/contentful_lite.rb

@@ -0,0 +1,12 @@
+require "contentful_lite/validations/entry"
+require "contentful_lite/version"
+require "contentful_lite/common_data"
+require "contentful_lite/link"
+require "contentful_lite/asset"
+require "contentful_lite/entry_mapping"
+require "contentful_lite/entry"
+require "contentful_lite/deleted_entry"
+require "contentful_lite/base_array"
+require "contentful_lite/assets_array"
+require "contentful_lite/entries_array"
+require "contentful_lite/client"

data/spec/asset_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::Asset do
+  let(:asset_hash) { JSON.parse(File.read('fixtures/assets/nyancat.json')) }
+  let(:instance) { ContentfulLite::Asset.new(asset_hash) }
+
+  describe '#attributes' do
+    it { expect(instance.title).to eq 'Nyan Cat' }
+    it { expect(instance.description).to eq '' }
+    it { expect(instance.url).to eq '//images.ctfassets.net/cfexampleapi/4gp6taAwW4CmSgumq2ekUm/9da0cd1936871b8d72343e895a00d611/Nyan_cat_250px_frame.png' }
+    it { expect(instance.file_name).to eq 'Nyan_cat_250px_frame.png' }
+    it { expect(instance.content_type).to eq 'image/png' }
+
+    context 'for unpublished assets without a file' do
+      let(:asset_hash) { JSON.parse(File.read('fixtures/assets/unpublished.json')) }
+
+      it { expect(instance.title).to be_nil }
+      it { expect(instance.description).to eq '' }
+      it { expect(instance.url).to be_nil }
+      it { expect(instance.file_name).to be_nil }
+      it { expect(instance.content_type).to be_nil }
+    end
+
+    context 'when requesting multiple locales at once' do
+      let(:asset_hash) { JSON.parse(File.read('fixtures/assets/nyancat_with_locales.json')) }
+
+      it { expect(instance.title).to eq 'Nyan Cat' }
+      it { expect(instance.description).to eq '' }
+      it { expect(instance.url).to eq '//images.ctfassets.net/cfexampleapi/4gp6taAwW4CmSgumq2ekUm/9da0cd1936871b8d72343e895a00d611/Nyan_cat_250px_frame.png' }
+      it { expect(instance.file_name).to eq 'Nyan_cat_250px_frame.png' }
+      it { expect(instance.content_type).to eq 'image/png' }
+      it { expect(instance.title(locale: 'tlh')).to eq "Nyan vIghro'" }
+      it { expect(instance.description(locale: 'tlh')).to eq '' }
+    end
+  end
+
+  describe '#contentful_link' do
+    subject { instance.contentful_link }
+
+    it { is_expected.to eq 'https://app.contentful.com/spaces/cfexampleapi/assets/nyancat' }
+  end
+
+  describe 'serializing' do
+    subject { Marshal.load(Marshal.dump(instance)) }
+
+    it { expect(subject.id).to eq(instance.id) }
+    it { expect(subject.created_at).to eq(instance.created_at) }
+    it { expect(subject.updated_at).to eq(instance.updated_at) }
+    it { expect(subject.retrieved_at).to eq(instance.retrieved_at) }
+    it { expect(subject.locale).to eq(instance.locale) }
+    it { expect(subject.revision).to eq(instance.revision) }
+    it { expect(subject.space_id).to eq(instance.space_id) }
+    it { expect(subject.environment_id).to eq(instance.environment_id) }
+    it { expect(subject.title).to eq(instance.title) }
+    it { expect(subject.description).to eq(instance.description) }
+    it { expect(subject.file_name).to eq(instance.file_name) }
+    it { expect(subject.content_type).to eq(instance.content_type) }
+    it { expect(subject.url).to eq(instance.url) }
+    it { expect(subject.file_details).to eq(instance.file_details) }
+  end
+end

data/spec/assets_array_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::AssetsArray do
+  let(:response) { JSON.parse(File.read('fixtures/assets/all.json')) }
+  let(:instance) { ContentfulLite::AssetsArray.new(response) }
+
+  describe 'should create an array of assets' do
+    it { expect(instance.first).to be_an ContentfulLite::Asset }
+    it { expect(instance.last).to be_an ContentfulLite::Asset }
+    it { expect(instance.sample).to be_an ContentfulLite::Asset }
+  end
+
+  context 'with multiple locales' do
+    let(:response) { JSON.parse(File.read('fixtures/assets/all_with_locales.json')) }
+
+    describe 'should create an array of assets' do
+      it { expect(instance.first).to be_an ContentfulLite::Asset }
+      it { expect(instance.first.title).to be_a String }
+    end
+  end
+
+  describe 'serializing' do
+    subject { Marshal.load(Marshal.dump(instance)) }
+
+    it { expect(subject.first.id).to eq(instance.first.id) }
+    it { expect(subject.first.file_name).to eq(instance.first.file_name) }
+    it { expect(subject.last.file_details).to eq(instance.last.file_details) }
+    it { expect(subject.last.id).to eq(instance.last.id) }
+    it { expect(subject.last.file_name).to eq(instance.last.file_name) }
+    it { expect(subject.last.file_details).to eq(instance.last.file_details) }
+  end
+end

data/spec/base_array_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::BaseArray do
+  let(:instance) { ContentfulLite::BaseArray.new(response) }
+
+  describe '#attributes' do
+    context 'for an array of assets' do
+      let(:response) { JSON.parse(File.read('fixtures/assets/all.json')) }
+
+      it { expect(instance.total).to eq 4 }
+      it { expect(instance.skip).to eq 0 }
+      it { expect(instance.limit).to eq 100 }
+    end
+  end
+
+  describe '#attributes' do
+    context 'for an array of entries' do
+      let(:response) { JSON.parse(File.read('fixtures/entries/all.json')) }
+
+      it { expect(instance.total).to eq 10 }
+      it { expect(instance.skip).to eq 0 }
+      it { expect(instance.limit).to eq 100 }
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::Client do
+  let(:instance) { ContentfulLite::Client.new(space_id: 'cfexampleapi', access_token: 'b4c0n73n7fu1') }
+
+  around(:each) do |example|
+    if defined?(cassette_name)
+      VCR.use_cassette("client/#{cassette_name}") do
+        example.run
+      end
+    else
+      example.run
+    end
+  end
+
+  describe '#entries' do
+    let(:cassette_name) { 'entries' }
+    let(:query) { {} }
+    subject do
+      instance.entries(query)
+    end
+
+    it { is_expected.to be_a(ContentfulLite::EntriesArray) }
+
+    context 'when the query is invalid' do
+      let(:cassette_name) { 'invalid_query' }
+      let(:query) { { invalid_parameter: 'invalid_value' } }
+
+      it { expect { subject }.to raise_error(ContentfulLite::Client::RequestError, "InvalidQuery: The query you sent was invalid. Probably a filter or ordering specification is not applicable to the type of a field.") }
+    end
+
+    context 'when the query has an array parameter' do
+      let(:cassette_name) { 'array_parameter' }
+      let(:query) { { 'sys.id[in]': ['nyancat', 'happycat'] } }
+
+      it { is_expected.to be_a(ContentfulLite::EntriesArray) }
+      it { expect(subject.size).to eq 2 }
+    end
+  end
+
+  describe '#entry' do
+    let(:cassette_name) { 'entry' }
+    let(:query) { {} }
+    let(:entry_id) { 'nyancat' }
+    subject do
+      instance.entry(entry_id, query)
+    end
+
+    it { is_expected.to be_a(ContentfulLite::Entry) }
+
+    context 'when the query is invalid' do
+      let(:cassette_name) { 'entry_invalid_query' }
+      let(:query) { { locale: 'invalid_value' } }
+
+      it { expect { subject }.to raise_error(ContentfulLite::Client::RequestError, "BadRequest: Unknown locale: invalid_value") }
+    end
+
+    context 'when the id is not found' do
+      let(:cassette_name) { 'entry_missings_id' }
+      let(:entry_id) { 'invalidcat' }
+
+      it { expect { subject }.to raise_error(ContentfulLite::Client::NotFoundError, "NotFound: The resource could not be found.") }
+    end
+  end
+
+  describe '#assets' do
+    let(:cassette_name) { 'assets' }
+    let(:query) { {} }
+    subject do
+      instance.assets(query)
+    end
+
+    it { is_expected.to be_a(ContentfulLite::AssetsArray) }
+
+    context 'when the query is invalid' do
+      let(:cassette_name) { 'assets_invalid_query' }
+      let(:query) { { invalid_parameter: 'invalid_value' } }
+
+      it { expect { subject }.to raise_error(ContentfulLite::Client::RequestError, "InvalidQuery: The query you sent was invalid. Probably a filter or ordering specification is not applicable to the type of a field.") }
+    end
+  end
+
+  describe '#asset' do
+    let(:cassette_name) { 'asset' }
+    let(:query) { {} }
+    let(:asset_id) { 'nyancat' }
+    subject do
+      instance.asset(asset_id, query)
+    end
+
+    it { is_expected.to be_a(ContentfulLite::Asset) }
+
+    context 'when the query is invalid' do
+      let(:cassette_name) { 'asset_invalid_query' }
+      let(:query) { { locale: 'invalid_value' } }
+
+      it { expect { subject }.to raise_error(ContentfulLite::Client::RequestError, "BadRequest: Unknown locale: invalid_value") }
+    end
+
+    context 'when the id is not found' do
+      let(:cassette_name) { 'asset_missings_id' }
+      let(:asset_id) { 'invalidcat' }
+
+      it { expect { subject }.to raise_error(ContentfulLite::Client::NotFoundError, "NotFound: The resource could not be found.") }
+    end
+  end
+
+  describe '#build_resource' do
+    let(:fixture) { 'entries/nyancat' }
+    let(:hash) { JSON.parse(File.read("fixtures/#{fixture}.json")) }
+    subject do
+      instance.build_resource(hash)
+    end
+
+    it { is_expected.to be_a(ContentfulLite::Entry) }
+
+    context 'when the resource is an asset' do
+      let(:fixture) { 'assets/nyancat' }
+
+      it { is_expected.to be_a(ContentfulLite::Asset) }
+    end
+
+    context 'when the resource is a DeletedEntry' do
+      let(:fixture) { 'entries/deleted_entry' }
+
+      it { is_expected.to be_a(ContentfulLite::DeletedEntry) }
+    end
+  end
+end

data/spec/common_data_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::CommonData do
+  let(:klass) { Class.new.include(described_class) }
+  let(:instance) { klass.new(raw_hash) }
+
+  describe '#attributes' do
+    context 'with an entry' do
+      let(:raw_hash) { JSON.parse(File.read('fixtures/entries/nyancat.json')) }
+
+      it { expect(instance.id).to eq 'nyancat' }
+      it { expect(instance.created_at).to eq DateTime.new(2013, 6, 27, 22, 46, 19.513) }
+      it { expect(instance.updated_at).to eq DateTime.new(2013, 9, 4, 9, 19, 39.027) }
+      it { expect(instance.locale).to eq 'en-US' }
+      it { expect(instance.revision).to eq 5 }
+      it { expect(instance.space_id).to eq 'cfexampleapi' }
+      it { expect(instance.environment_id).to eq 'master' }
+      it { expect(instance.retrieved_at).to be_a DateTime }
+    end
+  end
+
+  describe '#attributes' do
+    context 'with an asset' do
+      let(:raw_hash) { JSON.parse(File.read('fixtures/assets/nyancat.json')) }
+
+      it { expect(instance.id).to eq 'nyancat' }
+      it { expect(instance.created_at).to eq DateTime.new(2013, 9, 2, 14, 56, 34.240) }
+      it { expect(instance.updated_at).to eq DateTime.new(2013, 9, 2, 14, 56, 34.240) }
+      it { expect(instance.locale).to eq 'en-US' }
+      it { expect(instance.revision).to eq 1 }
+      it { expect(instance.space_id).to eq 'cfexampleapi' }
+      it { expect(instance.environment_id).to eq 'master' }
+      it { expect(instance.retrieved_at).to be_a DateTime }
+    end
+  end
+
+  describe '#fields' do
+    subject { instance.fields['name'] }
+
+    context 'for a single locale entry' do
+      let(:raw_hash) { JSON.parse(File.read('fixtures/entries/nyancat.json')) }
+
+      it { is_expected.to eq 'Nyan Cat' }
+
+      context 'when specific locale is requested' do
+        subject { instance.fields(locale: 'tlh')['name'] }
+
+        it { is_expected.to eq nil }
+      end
+    end
+
+    context 'for a multiple locale entry' do
+      let(:raw_hash) { JSON.parse(File.read('fixtures/entries/nyancat_with_locales.json')) }
+
+      it { is_expected.to eq 'Nyan Cat' }
+
+      context 'when specific locale is requested' do
+        subject { instance.fields(locale: 'tlh')['name'] }
+
+        it { is_expected.to eq "Nyan vIghro'" }
+      end
+    end
+  end
+
+  describe '#with_locale' do
+    subject { instance.with_locale('tlh') { instance.fields['name'] } }
+
+    context 'for a multiple locale entry' do
+      let(:raw_hash) { JSON.parse(File.read('fixtures/entries/nyancat_with_locales.json')) }
+
+      it { is_expected.to eq "Nyan vIghro'" }
+    end
+  end
+
+  describe '#to_link' do
+    let(:raw_hash) { JSON.parse(File.read('fixtures/entries/nyancat.json')) }
+
+    subject { instance.to_link }
+
+    it { expect(subject.id).to eq 'nyancat' }
+    it { expect(subject.type).to eq :entry }
+
+    context 'with an asset' do
+      let(:raw_hash) { JSON.parse(File.read('fixtures/assets/nyancat.json')) }
+
+      it { expect(subject.id).to eq 'nyancat' }
+      it { expect(subject.type).to eq :asset }
+    end
+  end
+
+  describe '#as_json' do
+    let(:raw_hash) { JSON.parse(File.read('fixtures/entries/nyancat.json')) }
+
+    subject { instance.as_json }
+
+    it { is_expected.to eq(raw_hash) }
+
+    context 'when rails is passing some other parameters as hash' do
+      let(:hash) { { template: "something", status: 200 } }
+      subject { instance.as_json(hash) }
+
+      it { is_expected.to eq(raw_hash) }
+    end
+
+    context 'when rails is passing parameters with named args syntax' do
+      subject { instance.as_json(template: "something", status: 200) }
+
+      it { is_expected.to eq(raw_hash) }
+    end
+  end
+end

data/spec/deleted_entry_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+RSpec.describe ContentfulLite::DeletedEntry do
+  let(:entry_hash) { JSON.parse(File.read('fixtures/entries/deleted_entry.json')) }
+  let(:instance) { ContentfulLite::DeletedEntry.new(entry_hash) }
+
+  describe '#attributes' do
+    it { expect(instance.content_type_id).to eq 'cat' }
+    it { expect(instance.id).to eq 'deletedcat' }
+  end
+
+  describe '#contentful_link' do
+    subject { instance.contentful_link }
+
+    it { expect { subject }.to raise_error NotImplementedError }
+  end
+
+  describe 'serializing' do
+    subject { Marshal.load(Marshal.dump(instance)) }
+
+    it { expect(subject.id).to eq(instance.id) }
+    it { expect(subject.created_at).to eq(instance.created_at) }
+    it { expect(subject.updated_at).to eq(instance.updated_at) }
+    it { expect(subject.retrieved_at).to eq(instance.retrieved_at) }
+    it { expect(subject.revision).to eq(instance.revision) }
+    it { expect(subject.space_id).to eq(instance.space_id) }
+    it { expect(subject.environment_id).to eq(instance.environment_id) }
+    it { expect(subject.content_type_id).to eq(instance.content_type_id) }
+  end
+end