hydramata-works 0.0.1.prerelease

data/spec/presenters/hydramata/works/fieldset_presenter_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_fast_helper'
+require 'hydramata/works/fieldset_presenter'
+require 'hydramata/works/entity'
+require 'hydramata/works/work_type'
+
+module Hydramata
+  module Works
+    describe FieldsetPresenter do
+      let(:fieldset_class) { Struct.new(:name, :work_type) }
+      let(:fieldset) { fieldset_class.new('my_fieldset', work_type) }
+      let(:work_type) { WorkType.new(identity: 'an entity type') }
+      let(:entity) { Entity.new(work_type: work_type) }
+      let(:template) { double('Template', render: true) }
+      subject { described_class.new(entity: entity, fieldset: fieldset, presentation_context: 'show', template_missing_exception: [RuntimeError]) }
+
+      it 'should render as per the template' do
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/fieldsets/an_entity_type/my_fieldset/show', object: subject).
+          ordered.
+          and_raise(RuntimeError)
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/fieldsets/my_fieldset/show', object: subject).
+          ordered.
+          and_raise(RuntimeError)
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/fieldsets/show', object: subject).
+          ordered.
+          and_return('YES')
+        expect(subject.render(template: template)).to eq('YES')
+      end
+
+      it 'should have #container_content_tag_attributes' do
+        expect(subject.container_content_tag_attributes).to have_key(:class)
+      end
+
+      it 'should have an #work_type' do
+        expect(subject.work_type).to eq(entity.work_type)
+      end
+
+      it 'should be an instance of the presented object\'s class' do
+        expect(subject.instance_of?(fieldset.class)).to be_truthy
+      end
+
+      it 'should also be an instance of the presenter class' do
+        expect(subject.instance_of?(described_class)).to be_truthy
+      end
+
+      it 'should have a #dom_class' do
+        expect(subject.dom_class).to eq('my-fieldset')
+      end
+
+      it 'should have a default partial prefixes' do
+        expect(subject.partial_prefixes).to eq([['an_entity_type', 'my_fieldset'], ['my_fieldset']])
+      end
+
+    end
+  end
+end

data/spec/presenters/hydramata/works/property_presenter_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_fast_helper'
+require 'hydramata/works/property_presenter'
+require 'hydramata/works/entity'
+
+module Hydramata
+  module Works
+    describe PropertyPresenter do
+      let(:entity) { Entity.new(work_type: 'an entity type') }
+      let(:property) { double('Property', predicate: 'my_property') }
+      let(:template) { double('Template', render: true) }
+      subject do
+        described_class.new(
+          property: property,
+          entity: entity,
+          presentation_context: 'show',
+          template_missing_exception: [RuntimeError]
+        )
+      end
+
+      it 'should attempt to render with diminishing specificity' do
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/properties/an_entity_type/my_property/show', object: subject).
+          ordered.
+          and_raise(RuntimeError)
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/properties/my_property/show', object: subject).
+          ordered.
+          and_raise(RuntimeError)
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/properties/show', object: subject).
+          ordered.
+          and_return('YES')
+        expect(subject.render(template: template)).to eq('YES')
+      end
+
+      it 'should have a default partial prefixes' do
+        expect(subject.partial_prefixes).to eq([['an_entity_type','my_property'], ['my_property']])
+      end
+
+    end
+  end
+end

data/spec/presenters/hydramata/works/value_presenter_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_fast_helper'
+require 'hydramata/works/value_presenter'
+require 'hydramata/works/entity'
+require 'hydramata/works/predicate'
+
+module Hydramata
+  module Works
+    describe ValuePresenter do
+      let(:entity) { Entity.new(work_type: 'an entity type') }
+      let(:predicate) { Predicate.new(identity: 'a predicate') }
+      let(:value) { double('Value') }
+      let(:template) { double('Template', render: true) }
+      subject do
+        described_class.new(
+          value: value,
+          entity: entity,
+          predicate: predicate,
+          presentation_context: 'show',
+          template_missing_exception: [RuntimeError]
+        )
+      end
+
+      it 'should attempt to render with diminishing specificity' do
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/values/an_entity_type/a_predicate/show', object: subject).
+          ordered.
+          and_raise(RuntimeError)
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/values/a_predicate/show', object: subject).
+          ordered.
+          and_raise(RuntimeError)
+        expect(template).to receive(:render).
+          with(partial: 'hydramata/works/values/show', object: subject).
+          ordered.
+          and_return('YES')
+        expect(subject.render(template: template)).to eq('YES')
+      end
+
+      it 'should render the value as a string' do
+        allow(template).to receive(:render).and_raise(RuntimeError)
+        expect(subject.render(template: template)).to eq(value.to_s)
+      end
+
+      it 'should have a default partial prefixes' do
+        expect(subject.partial_prefixes).to eq([['an_entity_type','a_predicate'], ['a_predicate']])
+      end
+    end
+  end
+end

data/spec/renderers/hydramata/works/entity_renderer_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_fast_helper'
+require 'hydramata/works/entity_renderer'
+
+module Hydramata
+  module Works
+    describe EntityRenderer do
+      let(:entity) { double('Entity', render: true) }
+      let(:presentation_structure) { double('Presentation Structure') }
+      let(:template) { double('Template') }
+      subject do
+        Hydramata::Works::EntityRenderer.new(entity: entity, format: :html, template: template)
+      end
+
+      it 'should render the template based on all the inputs' do
+        subject.render
+        expect(entity).to have_received(:render).with(template: template)
+      end
+
+      it 'should default to :html format' do
+        renderer = Hydramata::Works::EntityRenderer.new(entity: entity, template: template)
+        expect(renderer.format).to eq(:html)
+      end
+    end
+  end
+end

data/spec/spec_active_record_helper.rb

@@ -0,0 +1,30 @@
+# This helper provides a x2 speed increase over the 'spec_slow_helper'
+#
+# To validate this assumption, find a spec for an ActiveRecord object
+# (eg spec/hydramata/works/predicate_spec.rb)
+# $ time rspec spec/hydramata/works/predicate_spec.rb
+#
+# Then change the "require 'spec_active_record_helper'" to "require 'spec_slow_helper'"
+# $ time rspec spec/hydramata/works/predicate_spec.rb
+
+require 'active_record'
+require 'spec_fast_helper'
+
+if !defined?(Rails)
+  # Sometimes this will be invoked when Rails is defined. In that case the relative
+  # path is ../internal. When Rails is not defined the relative path is different.
+  # By providing an absolute path, I avoid either of those silly things.
+  database = File.expand_path('../internal/db/development.sqlite3', __FILE__)
+
+  connection_info = { adapter: 'sqlite3', database: database, pool: 5, timeout: 5000 }
+  ActiveRecord::Base.establish_connection(connection_info)
+end
+
+RSpec.configure do |config|
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      fail ActiveRecord::Rollback
+    end
+  end
+end

data/spec/spec_fast_helper.rb

@@ -0,0 +1,12 @@
+unless defined?(Rails)
+  Dir[File.expand_path('../../app/*', __FILE__)].each do |dir|
+    $LOAD_PATH << dir
+  end
+  $LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+  unless defined?(require_dependency)
+    def require_dependency(*files)
+      require *files
+    end
+  end
+end

data/spec/spec_slow_helper.rb

@@ -0,0 +1,56 @@
+# Why is this a spec_slow_helper instead of spec_helper
+# Because it is extremely slow to load all of the following dependencies:
+#
+# * SimpleCov
+# * EngineCart (and therefore the underlying internal Rails application)
+# * Rails
+#
+# But overtime the slowness has grown.
+ENV['RAILS_ENV'] ||= 'test'
+if ENV['COV'] || ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start 'rails'
+  SimpleCov.command_name 'spec'
+end
+
+if ENV['TRAVIS']
+  require 'coveralls'
+  Coveralls.wear!('rails')
+end
+
+require 'engine_cart'
+require File.expand_path('../internal/config/environment.rb',  __FILE__)
+
+EngineCart.load_application!
+
+require 'rspec/rails'
+require 'rspec-html-matchers'
+require 'database_cleaner'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require 'spec_helper'` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.raise_errors_for_deprecations!
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+end

data/spec/spec_view_helper.rb

@@ -0,0 +1,14 @@
+# I'm deliberately not including this, as I was hoping to keep the views tested
+# in extreme isolation.
+# require 'spec_fast_helper'
+
+require 'active_support'
+require 'action_view'
+require 'action_controller'
+
+require 'active_support/core_ext/hash/reverse_merge'
+
+require 'rspec/rails'
+require 'rspec-html-matchers'
+
+ActionController::Base.prepend_view_path(File.expand_path('../../app/views', __FILE__))

data/spec/test_app_templates/lib/generators/test_app_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators'
+
+class TestAppGenerator < Rails::Generators::Base
+  source_root './spec/test_app_templates'
+
+  # if you need to generate any additional configuration
+  # into the test app, this generator will be run immediately
+  # after setting up the application
+
+  # def install_engine
+  #   generate 'hydramata-works:install'
+  # end
+
+  def run_migrations
+    rake 'db:create'
+    rake 'hydramata_works:install:migrations'
+    rake 'db:migrate'
+    rake 'db:test:prepare'
+  end
+
+end

data/spec/views/hydramata/works/fieldsets/_edit.html.erb_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_view_helper'
+
+# As of 3.0.x :type tags are no longer inferred.
+# This means, without the `type: :view` tag, the render method does not exist
+# in the example context
+describe 'hydramata/works/fieldsets/_edit.html.erb', type: :view do
+  let(:form) { double('Form') }
+  let(:object) { double('Object', fieldsets: [fieldset1, fieldset2], dom_class: 'my-dom-class') }
+
+  let(:object) { double('Object', t: true, properties: [property1, property2], dom_class: 'my-dom-class') }
+
+  # A short circuit as the render does not normally
+  let(:property1) { double('Property', render: '<div class="property1">Property 1</div>'.html_safe) }
+  let(:property2) { double('Property', render: '<div class="property2">Property 2</div>'.html_safe) }
+
+  it 'renders the object and fieldsets' do
+    expect(object).to receive(:t).with(:name).and_return('Heading')
+    render partial: 'hydramata/works/fieldsets/edit', object: object, locals: { form: form }
+
+    expect(property1).to have_received(:render).with(template: view, locals: { form: form } )
+    expect(property2).to have_received(:render).with(template: view, locals: { form: form } )
+    expect(rendered).to have_tag('fieldset.my-dom-class.fieldset') do
+      with_tag('caption', text: 'Heading')
+      with_tag('.property1', text: 'Property 1')
+      with_tag('.property2', text: 'Property 2')
+    end
+  end
+
+end

data/spec/views/hydramata/works/fieldsets/_show.html.erb_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_view_helper'
+
+# As of 3.0.x :type tags are no longer inferred.
+# This means, without the `type: :view` tag, the render method does not exist
+# in the example context
+describe 'hydramata/works/fieldsets/_show.html.erb', type: :view do
+  let(:object) { double('Object', t: true, properties: [property1, property2],  container_content_tag_attributes: { class: 'my-dom-class' } ) }
+
+  # A short circuit as the render does not normally
+  let(:property1) { double('Property', render: '<div class="property1">Property 1</div>'.html_safe) }
+  let(:property2) { double('Property', render: '<div class="property2">Property 2</div>'.html_safe) }
+
+  it 'renders the object and fieldsets' do
+    expect(object).to receive(:t).with(:name).and_return('Heading')
+    render partial: 'hydramata/works/fieldsets/show', object: object
+
+    expect(property1).to have_received(:render).with(template: view)
+    expect(property2).to have_received(:render).with(template: view)
+    expect(rendered).to have_tag('section.my-dom-class') do
+      with_tag('.heading', text: 'Heading')
+      with_tag('.metadata .property1', text: 'Property 1')
+      with_tag('.metadata .property2', text: 'Property 2')
+    end
+  end
+end

data/spec/views/hydramata/works/properties/_edit.html.erb_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_view_helper'
+
+# As of 3.0.x :type tags are no longer inferred.
+# This means, without the `type: :view` tag, the render method does not exist
+# in the example context
+describe 'hydramata/works/properties/_edit.html.erb', type: :view do
+  let(:object) { double('Object', predicate: 'my_predicate', t: true, dom_class: 'my-dom-class') }
+  let(:form) { double('Form') }
+
+  it 'renders the object and fieldsets' do
+    expect(object).to receive(:each_with_index).and_yield('value1', 0).and_yield('value2', 1)
+    expect(object).to receive(:t).with(:predicate).and_return('Label')
+    render partial: 'hydramata/works/properties/edit', object: object, locals: { form: form }
+
+    expect(rendered).to have_tag('.my-dom-class') do
+      with_tag('label', text: 'Label')
+      with_tag('.values input#work_my_predicate_0', value: '', with: { name: 'work[my_predicate][]' })
+      with_tag('.values input#work_my_predicate_1', value: 'value1', with: { name: 'work[my_predicate][]' })
+      with_tag('.values input#work_my_predicate_2', value: 'value2', with: { name: 'work[my_predicate][]' })
+    end
+  end
+end

data/spec/views/hydramata/works/properties/_show.html.erb_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_view_helper'
+
+# As of 3.0.x :type tags are no longer inferred.
+# This means, without the `type: :view` tag, the render method does not exist
+# in the example context
+describe 'hydramata/works/properties/_show.html.erb', type: :view do
+  let(:value1) { double('Value 1', render: '<dd class="my-dom-class value">value1</dd>'.html_safe ) }
+  let(:value2) { double('Value 2', render: '<dd class="my-dom-class value">value2</dd>'.html_safe ) }
+  let(:object) { double('Object', t: true, dom_class: 'my-dom-class', values: [value1, value2]) }
+
+  it 'renders the object and fieldsets' do
+    expect(object).to receive(:container_content_tag_attributes).with(class: 'label').and_return(class: ['my-dom-class', 'label'])
+    expect(object).to receive(:container_content_tag_attributes).with(class: 'value').and_return(class: ['my-dom-class', 'value']).at_least(1).times
+    expect(object).to receive(:t).with(:name).and_return('Label')
+    render partial: 'hydramata/works/properties/show', object: object
+
+    expect(rendered).to have_tag('.my-dom-class.label', text: 'Label')
+    expect(rendered).to have_tag('.my-dom-class.value', text: 'value1')
+    expect(rendered).to have_tag('.my-dom-class.value', text: 'value2')
+
+  end
+end

data/spec/views/hydramata/works/works/_edit.html.erb_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_view_helper'
+
+# As of 3.0.x :type tags are no longer inferred.
+# This means, without the `type: :view` tag, the render method does not exist
+# in the example context
+describe 'hydramata/works/works/_edit.html.erb', type: :view do
+  let(:object) { double('Object', fieldsets: [fieldset1, fieldset2], dom_class: 'my-dom-class') }
+
+  # A short circuit as the render does not normally
+  let(:fieldset1) { double('Fieldset', render: '<div class="set1">Fieldset 1</div>'.html_safe) }
+  let(:fieldset2) { double('Fieldset', render: '<div class="set2">Fieldset 2</div>'.html_safe) }
+
+  it 'renders the object and fieldsets' do
+    render partial: 'hydramata/works/works/edit', object: object
+
+    expect(fieldset1).to have_received(:render).with(template: view, locals: { form: kind_of(ActionView::Helpers::FormBuilder) })
+    expect(fieldset2).to have_received(:render).with(template: view, locals: { form: kind_of(ActionView::Helpers::FormBuilder) })
+    expect(rendered).to have_tag('form.work.my-dom-class') do
+      with_tag('.set1', text: 'Fieldset 1')
+      with_tag('.set2', text: 'Fieldset 2')
+    end
+  end
+end