workarea-core 3.4.45 → 3.5.0.beta.1

data/test/models/workarea/releasable_test.rb

@@ -113,44 +113,19 @@ module Workarea
       assert_equal(1, model.changesets.length)
       assert_equal(@release.id, model.changesets.first.release_id)
       assert_equal('Changed', model.changesets.first.changeset['name'])
+      assert_equal('Test', model.changesets.first.original['name'])
 
       assert_equal('Bar', model.bars.first.name)
       assert_equal(1, model.bars.first.changesets.length)
       assert_equal(@release.id, model.bars.first.changesets.first.release_id)
       assert_equal('Bar Changed', model.bars.first.changesets.first.changeset['name'])
+      assert_equal('Bar', model.bars.first.changesets.first.original['name'])
 
       assert_equal('Baz', model.baz.name)
       assert_equal(1, model.baz.changesets.length)
       assert_equal(@release.id, model.baz.changesets.first.release_id)
       assert_equal('Baz Changed', model.baz.changesets.first.changeset['name'])
-    end
-
-    def test_save_does_not_log_undone_changes
-      model = Foo.create!(
-        name: 'Test',
-        blank_field: 'test'
-      )
-
-      Release.with_current(@release.id) do
-        model.name = 'Changed'
-        model.blank_field = 'changed'
-        model.save!
-
-        model.name = 'Test'
-        model.blank_field = 'changed'
-        model.save!
-      end
-
-      assert(model.changesets.first.present?)
-      assert_equal('changed', model.changesets.first.changeset['blank_field'])
-      assert_nil(model.changesets.first.changeset['name'])
-
-      Release.with_current(@release.id) do
-        model.blank_field = 'test'
-        model.save!
-      end
-
-      assert(model.changesets.empty?)
+      assert_equal('Baz', model.baz.changesets.first.original['name'])
     end
 
     def test_save_does_not_log_release_changes_if_invalid
@@ -215,16 +190,19 @@ module Workarea
       assert_equal(1, model.changesets.length)
       assert_equal(@release.id, model.changesets.first.release_id)
       assert_equal('Changed', model.changesets.first.changeset['name'])
+      assert_equal('Test', model.changesets.first.original['name'])
 
       assert_equal('Bar', model.bars.first.name)
       assert_equal(1, model.bars.first.changesets.length)
       assert_equal(@release.id, model.bars.first.changesets.first.release_id)
       assert_equal('Bar Changed', model.bars.first.changesets.first.changeset['name'])
+      assert_equal('Bar', model.bars.first.changesets.first.original['name'])
 
       assert_equal('Baz', model.baz.name)
       assert_equal(1, model.baz.changesets.length)
       assert_equal(@release.id, model.baz.changesets.first.release_id)
       assert_equal('Baz Changed', model.baz.changesets.first.changeset['name'])
+      assert_equal('Baz', model.baz.changesets.first.original['name'])
     end
 
     def test_save_does_not_save_timestamp_changes
@@ -236,6 +214,9 @@ module Workarea
 
       fields_in_change = model.changesets.first.changeset.keys
       refute_includes(fields_in_change, 'updated_at')
+
+      fields_in_original = model.changesets.first.original.keys
+      refute_includes(fields_in_original, 'updated_at')
     end
 
     def test_save_does_not_save_slug_changes
@@ -261,21 +242,9 @@ module Workarea
 
       fields_in_change = model.changesets.first.changeset.keys
       refute_includes(fields_in_change, 'blank_field')
-    end
-
-    def test_save_can_schedule_activation
-      model = Foo.create!(
-        name: 'Test',
-        active: true,
-        activate_with: @release.id
-      )
-
-      model.reload
 
-      refute(model.active)
-      assert_equal(1, model.changesets.length)
-      assert_equal(@release.id, model.changesets.first.release_id)
-      assert(model.changesets.first.changeset['active'])
+      fields_in_original = model.changesets.first.original.keys
+      refute_includes(fields_in_original, 'blank_field')
     end
 
     def test_save_ignores_illegal_values
@@ -291,34 +260,6 @@ module Workarea
       assert_equal(0, model.changesets.length)
     end
 
-    def test_save_can_schedule_activation_for_an_embedded_document
-      model = Foo.create!(name: 'Test')
-
-      embedded_1 = model.bars.create!(
-        name: 'Bar',
-        active: true,
-        activate_with: @release.id
-      )
-
-      embedded_2 = model.bars.create!(
-        name: 'Baz',
-        active: true,
-        activate_with: @release.id
-      )
-
-      model.reload
-
-      refute(embedded_1.active)
-      assert_equal(1, embedded_1.changesets.length)
-      assert_equal(@release.id, embedded_1.changesets.first.release_id)
-      assert(embedded_1.changesets.first.changeset['active'])
-
-      refute(embedded_2.active)
-      assert_equal(1, embedded_2.changesets.length)
-      assert_equal(@release.id, embedded_2.changesets.first.release_id)
-      assert(embedded_2.changesets.first.changeset['active'])
-    end
-
     def test_destroys_related_changesets
       model = Foo.create!(
         name: 'Test',
@@ -361,6 +302,7 @@ module Workarea
       assert_equal(1, model.changesets.length)
       assert_equal(@release.id, model.changesets.first.release_id)
       assert_equal('Changed', model.changesets.first.changeset['name'])
+      assert_equal('Test', model.changesets.first.original['name'])
     end
 
     def test_destroys_a_changeset_where_it_is_the_only_change_if_embedded
@@ -407,73 +349,80 @@ module Workarea
       assert_equal('Baz Changed', model.baz.name)
     end
 
-    def test_undo
-      model = Foo.create!(
-        name: 'Test',
-        bars: [{ name: 'Bar' }],
-        baz: { name: 'Baz' }
-      )
+    def test_deleting_embedded
+      model = Foo.create!(name: 'Foo', bars: [{ name: 'Test' }])
+      @release.as_current { model.bars.first.destroy }
 
-      Release.with_current(@release.id) do
-        model.name = 'Changed'
-        model.save!
-
-        model.bars.first.name = 'Bar Changed'
-        model.bars.first.save!
+      model.reload
+      assert(model.bars.first.active?)
 
-        model.baz.name = 'Baz Changed'
-        model.baz.save!
+      @release.as_current do
+        model.reload
+        refute(model.bars.first.active?)
       end
+    end
 
-      @release.changesets.each(&:publish!)
-      model.reload
-
-      assert_equal('Changed', model.name)
-      assert_equal('Bar Changed', model.bars.first.name)
-      assert_equal('Baz Changed', model.baz.name)
+    def test_in_release
+      model = Foo.create!(name: 'Foo')
+      @release.as_current { model.update!(name: 'Bar') }
 
-      @release.changesets.each(&:undo!)
       model.reload
-
-      assert_equal('Test', model.name)
-      assert_equal('Bar', model.bars.first.name)
-      assert_equal('Baz', model.baz.name)
+      in_release = model.in_release(@release)
+      assert_equal('Bar', in_release.name)
+      refute_equal(in_release.object_id, model.object_id)
+
+      @release.as_current { model.reload }
+      in_release = model.in_release(nil)
+      assert_equal('Foo', in_release.name)
+      refute_equal(in_release.object_id, model.object_id)
     end
 
-    def test_activates_with_current_release
-      model = Foo.create!(name: 'Test', active: false)
-      refute(model.activates_with_current_release?)
+    def test_skip_changeset
+      model = Foo.create!(name: 'Foo')
 
-      Release.with_current(@release.id) do
-        model.active = true
-        model.save!
+      @release.as_current do
+        model.skip_changeset { model.update!(name: 'Bar') }
+      end
 
-        model.reload
-        assert(model.activates_with_current_release?)
+      assert_equal('Bar', model.reload.name)
+      assert_equal(0, model.changesets.count)
+
+      assert_raises do
+        @release.as_current do
+          model.skip_changeset do
+            model.update!(name: 'Baz')
+            raise 'test'
+          end
+        end
       end
 
-      model.reload
-      refute(model.activates_with_current_release?)
+      @release.as_current { model.update!(name: 'Qoo') }
+      assert_equal('Baz', model.reload.name)
+      assert_equal(1, model.changesets.count)
     end
 
-    def test_creating_and_activating_embedded
-      model = Foo.create!(name: 'Foo')
+    def test_changesets_with_children
+      model = Foo.create!(
+        name: 'Test',
+        bars: [{ name: 'Bar' }],
+        baz: { name: 'Baz' }
+      )
 
-      embedded = Release.with_current(@release.id) do
-        model.bars.create!(
-          name: 'Test',
-          active: true,
-          activate_with: @release.id
-        )
-      end
+      assert_empty(model.changesets_with_children)
 
-      model.reload
+      @release.as_current { model.update!(name: 'Test 2') }
+      assert_equal(model.changesets, model.changesets_with_children)
+
+      @release.as_current { model.bars.first.update!(name: 'Bar 2') }
+      assert_equal(2, model.changesets_with_children.size)
+      assert_includes(model.changesets_with_children, model.changesets.first)
+      assert_includes(model.changesets_with_children, model.bars.first.changesets.first)
 
-      refute(embedded.active)
-      assert_equal(1, embedded.changesets.length)
-      assert_equal(@release.id, embedded.changesets.first.release_id)
-      assert(embedded.changesets.first.changeset['active'])
-      assert(embedded.changesets.first.document_path.present?)
+      @release.as_current { model.baz.update!(name: 'Baz 2') }
+      assert_equal(3, model.changesets_with_children.size)
+      assert_includes(model.changesets_with_children, model.changesets.first)
+      assert_includes(model.changesets_with_children, model.bars.first.changesets.first)
+      assert_includes(model.changesets_with_children, model.baz.changesets.first)
     end
   end
 end

data/test/models/workarea/release/changeset_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module Workarea
+  class Release
+    class ChangesetTest < TestCase
+      def test_build_undo
+        releasable = create_page(name: 'Foo')
+        release = create_release
+        release.as_current { releasable.update_attributes!(name: 'Bar') }
+        changeset = release.changesets.first
+
+        undo = changeset.build_undo(release: create_release)
+        assert_equal(releasable, undo.releasable)
+        assert_equal(changeset.document_path, undo.document_path)
+        assert_match(/Foo/, undo.changeset.to_s)
+        assert_equal('Foo', releasable.name)
+
+        other_release = create_release
+        other_release.as_current { releasable.update_attributes!(name: 'Baz') }
+
+        other_release.as_current do
+          undo = changeset.build_undo(release: create_release)
+          assert_equal(releasable, undo.releasable)
+          assert_equal(changeset.document_path, undo.document_path)
+          assert_match(/Foo/, undo.changeset.to_s)
+          assert_equal('Foo', releasable.name)
+        end
+
+        other_release.update_attributes!(publish_at: 1.day.from_now)
+        release.update_attributes!(publish_at: 2.days.from_now)
+        changeset.reload
+
+        undo = changeset.build_undo(release: create_release)
+        assert_equal(releasable, undo.releasable)
+        assert_equal(changeset.document_path, undo.document_path)
+        assert_match(/Baz/, undo.changeset.to_s)
+        assert_equal('Foo', releasable.name)
+      end
+    end
+  end
+end

data/test/models/workarea/release_jobs_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module Workarea
+  class ReleaseJobsTest < TestCase
+    setup :setup_sidekiq
+    teardown :teardown_sidekiq
+
+    def setup_sidekiq
+      Sidekiq::Testing.disable!
+
+      @scheduled_set = Sidekiq::ScheduledSet.new
+      @scheduled_set.clear
+    end
+
+    def teardown_sidekiq
+      Sidekiq::Testing.inline!
+    end
+
+    def test_save_updates_the_publish_job
+      release = create_release
+      release.publish_at = Time.current + 1.month
+
+      release.save
+      release.reload
+
+      assert(release.publish_job_id.present?)
+    end
+
+    def test_save_does_not_save_the_publish_job_id_when_not_changing_publish_date
+      release = create_release
+      assert(release.publish_job_id.blank?)
+      assert_equal(0, @scheduled_set.size)
+    end
+
+    def test_removing_publish_at_removes_job
+      release = create_release(publish_at: 1.week.from_now)
+      assert(release.publish_job_id.present?)
+      assert_equal(1, @scheduled_set.size)
+
+      release.update_attributes!(publish_at: nil)
+      release.reload
+      assert(release.publish_job_id.blank?)
+      assert_equal(0, @scheduled_set.size)
+    end
+
+    def test_destroy_deletes_the_publish_job
+      release = create_release(publish_job_id: '1234')
+      release.destroy
+      assert_equal(0, @scheduled_set.size)
+    end
+  end
+end

data/test/models/workarea/release_previewing_test.rb

@@ -0,0 +1,43 @@
+
+require 'test_helper'
+
+module Workarea
+  class ReleasePreviewingTest < TestCase
+    class Foo
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      include Releasable
+      field :name, type: String
+      field :description, type: String
+    end
+
+    def test_basic_previewing
+      first_release = create_release(publish_at: 1.day.from_now)
+      second_release = create_release(publish_at: 2.days.from_now)
+
+      model = Foo.create!(name: 'Test')
+      first_release.as_current do
+        model.name = 'Changed'
+        model.save!
+      end
+
+      model.reload
+      second_release.as_current do
+        model.description = 'Description'
+        model.save!
+      end
+
+      first_release.as_current do
+        model.reload
+        assert_equal('Changed', model.name)
+        assert_nil(model.description)
+      end
+
+      second_release.as_current do
+        model.reload
+        assert_equal('Changed', model.name)
+        assert_equal('Description', model.description)
+      end
+    end
+  end
+end

data/test/models/workarea/release_test.rb

@@ -44,6 +44,16 @@ module Workarea
       end
     end
 
+    def test_scheduled
+      blank = create_release(publish_at: nil)
+      first = create_release(publish_at: 1.day.from_now)
+      second = create_release(publish_at: 2.days.from_now)
+      third = create_release(publish_at: 3.days.from_now)
+
+      assert_equal([first, second, third], Release.scheduled.desc(:publish_at))
+      assert_equal([first], Release.scheduled(before: 2.days.from_now))
+    end
+
     def test_unscheduled_does_not_return_scheduled_or_published_releases
       create_release(publish_at: Time.current + 1.week, published_at: nil)
       create_release(publish_at: nil, published_at: Time.current - 1.week)
@@ -100,57 +110,24 @@ module Workarea
       assert_equal([release_1, release_2, release_3], result)
     end
 
-    def test_undone_within_includes_releases_within_a_specified_range
-      create_release(publish_at: 1.month.from_now, undo_at: 2.months.from_now)
-      release_2 = create_release(publish_at: 1.day.from_now, undo_at: 1.day.from_now)
-
-      result = Release.undone_within(Time.current, 2.days.from_now)
-      assert_equal([release_2], result)
-    end
+    def test_sort_by_publish
+      first = create_release(publish_at: 1.day.from_now)
+      second = create_release(publish_at: 2.days.from_now)
+      third = create_release(publish_at: 3.days.from_now)
 
-    def test_is_sorted_by_undone_undo_time
-      release_3 = create_release(published_at: 1.hour.ago, undo_at: 1.hour.from_now)
-      release_2 = create_release(published_at: 2.days.ago, undone_at: 1.day.ago)
-      release_1 = create_release(published_at: 1.week.ago, undone_at: 2.days.ago)
+      assert_equal([first, second, third], Release.all.sort_by_publish)
 
-      result = Release.undone_within(3.days.ago, 3.days.from_now)
-      assert_equal([release_1, release_2, release_3], result)
+      fourth = create_release(publish_at: first.publish_at)
+      assert_equal([first, fourth, second, third], Release.all.sort_by_publish)
     end
 
     def test_publish_sets_publish_at_to_nil
-      release = create_release(
-        publish_at: 1.week.from_now,
-        undone_at: 1.week.ago
-      )
+      release = create_release(publish_at: 1.week.from_now)
       release.publish!
       release.reload
       assert(release.publish_at.blank?)
     end
 
-    def test_publish_sets_undone_at_to_nil
-      release = create_release(
-        publish_at: 1.week.from_now,
-        undone_at: 1.week.ago
-      )
-      release.publish!
-      release.reload
-      assert(release.undone_at.blank?)
-    end
-
-    def test_undo_sets_undo_at_to_nil_if_in_the_future
-      release = create_release(undo_at: 1.week.from_now)
-      release.undo!
-      release.reload
-      assert(release.undo_at.blank?)
-    end
-
-    def test_undo_sets_undone_at
-      release = create_release
-      release.undo!
-      release.reload
-      assert(release.undone_at.present?)
-    end
-
     def test_scheduled
       release = Release.new
       refute(release.scheduled?)
@@ -183,133 +160,62 @@ module Workarea
       assert(release.published?)
     end
 
-    def test_cannot_undo_without_scheduled_publish
-      release = Release.new(name: 'Foo', undo_at: 2.hours.from_now)
+    def test_scheduled_before
+      one_week_from_now = 1.week.from_now
 
-      refute(release.valid?, 'Release is valid with no publish date')
-      assert_includes(release.errors.full_messages.to_sentence, I18n.t('workarea.errors.messages.undo_unpublished_release'))
+      one = create_release(publish_at: one_week_from_now)
+      two = create_release(publish_at: nil)
+      three = create_release(publish_at: 8.days.from_now)
+      four = create_release(publish_at: 6.days.from_now)
+      five = create_release(publish_at: one_week_from_now)
+      six = create_release(publish_at: 4.days.from_now)
 
-      release.publish_at = 1.hour.from_now
-
-      assert(release.valid?)
-      assert(release.save!)
-
-      release.publish_at = nil
-      release.published_at = 1.hour.ago
-
-      assert(release.save!)
-
-      release.published_at = nil
-
-      refute(release.valid?)
-      assert_includes(release.errors.full_messages.to_sentence, I18n.t('workarea.errors.messages.undo_unpublished_release'))
+      assert_equal([six, four, five], one.scheduled_before)
+      assert_equal([], two.scheduled_before)
+      assert_equal([six, four, one, five], three.scheduled_before)
+      assert_equal([six], four.scheduled_before)
+      assert_equal([six, four, one], five.scheduled_before)
+      assert_equal([], six.scheduled_before)
     end
 
-    def test_ordered_changesets
-      release = create_release
-      [
-        { releasable_type: 'Workarea::Catalog::Category', releasable_id: '123' },
-        { releasable_type: 'Workarea::Catalog::Product', releasable_id: 'PROD1' },
-        { releasable_type: 'Workarea::Catalog::Variant', releasable_id: 'VAR1' },
-        { releasable_type: 'Workarea::Content::Page', releasable_id: 'PAGE1' },
-        { releasable_type: 'Workarea::Navigation::Menu', releasable_id: 'NAV1' },
-        { releasable_type: 'Workarea::Content', releasable_id: 'CON1' },
-        { releasable_type: 'Workarea::Search::Customization', releasable_id: 'CUS1' },
-        { releasable_type: 'Workarea::Content::Block', releasable_id: 'BLC1' }
-      ].each { |changeset| release.changesets.build(changeset) }
-
-      assert_equal(
-        %w(
-          Workarea::Catalog::Variant
-          Workarea::Catalog::Product
-          Workarea::Content::Block
-          Workarea::Content
-          Workarea::Content::Page
-          Workarea::Catalog::Category
-          Workarea::Search::Customization
-          Workarea::Navigation::Menu
-        ),
-        release.ordered_changesets.map(&:releasable_type)
-      )
-    end
-  end
-
-  class ReleaseJobsTest < TestCase
-    setup :setup_sidekiq
-    teardown :teardown_sidekiq
+    def test_scheduled_after
+      one_week_from_now = 1.week.from_now
 
-    def setup_sidekiq
-      Sidekiq::Testing.disable!
+      one = create_release(name: '1', publish_at: one_week_from_now)
+      two = create_release(name: '2', publish_at: nil)
+      three = create_release(name: '3', publish_at: 8.days.from_now)
+      four = create_release(name: '4', publish_at: 6.days.from_now)
+      five = create_release(name: '5', publish_at: one_week_from_now)
+      six = create_release(name: '6', publish_at: 4.days.from_now)
 
-      @scheduled_set = Sidekiq::ScheduledSet.new
-      @scheduled_set.clear
+      assert_equal([five, three], one.scheduled_after)
+      assert_equal([], two.scheduled_after)
+      assert_equal([], three.scheduled_after)
+      assert_equal([one, five, three], four.scheduled_after)
+      assert_equal([one, three], five.scheduled_after)
+      assert_equal([four, one, five, three], six.scheduled_after)
     end
 
-    def teardown_sidekiq
-      Sidekiq::Testing.inline!
-    end
-
-    def test_save_updates_the_publish_job
+    def test_previous
       release = create_release
-      release.publish_at = Time.current + 1.month
+      assert_nil(release.previous)
 
-      release.save
-      release.reload
+      release.update_attributes!(publish_at: 1.week.from_now)
+      assert_nil(release.previous)
 
-      assert(release.publish_job_id.present?)
-    end
+      first = create_release(publish_at: 1.day.from_now)
+      assert_equal(first, release.previous)
 
-    def test_save_does_not_save_the_publish_job_id_when_not_changing_publish_date
-      release = create_release
-      assert(release.publish_job_id.blank?)
-      assert_equal(0, @scheduled_set.size)
+      third = create_release(publish_at: 2.days.from_now)
+      assert_equal(third, release.previous)
     end
 
-    def test_removing_publish_at_removes_job
-      release = create_release(publish_at: 1.week.from_now)
-      assert(release.publish_job_id.present?)
-      assert_equal(1, @scheduled_set.size)
-
-      release.update_attributes!(publish_at: nil)
-      release.reload
-      assert(release.publish_job_id.blank?)
-      assert_equal(0, @scheduled_set.size)
-    end
-
-    def test_save_updates_the_undo_job
-      release = create_release(publish_at: 2.weeks.from_now, undo_at: 1.month.from_now)
-
-      assert(release.undo_job_id.present?)
-    end
-
-    def test_save_does_not_save_the_undo_job_id_when_not_changing_undo_date
+    def test_build_undo
       release = create_release
-      release.save
-      assert(release.undo_job_id.blank?)
-      assert_equal(0, @scheduled_set.size)
-    end
-
-    def test_removing_undo_at_removes_job
-      release = create_release(publish_at: 1.week.from_now, undo_at: 2.weeks.from_now)
-      assert(release.undo_job_id.present?)
-      assert_equal(2, @scheduled_set.size)
-
-      release.update_attributes!(undo_at: nil)
-      release.reload
-      assert(release.undo_job_id.blank?)
-      assert_equal(1, @scheduled_set.size)
-    end
-
-    def test_destroy_deletes_the_publish_job
-      release = create_release(publish_job_id: '1234')
-      release.destroy
-      assert_equal(0, @scheduled_set.size)
-    end
-
-    def test_destroy_deletes_the_undo_job
-      release = create_release(undo_job_id: '1234')
-      release.destroy
-      assert_equal(0, @scheduled_set.size)
+      undo = release.build_undo
+      assert(undo.name.present?)
+      assert_equal(undo, release.undo)
+      assert_equal(release, undo.undoes)
     end
   end
 end