Skip to content

A platform for community discussion. Free, open, simple.

37.9 KB
Raw Blame
# frozen_string_literal: true

require "securerandom"

describe Post do
  before do
    freeze_time
    Jobs.run_immediately!
    SiteSetting.discourse_events_enabled = true
    SiteSetting.discourse_post_event_enabled = true
  end

  fab!(:user) { Fabricate(:user, admin: true, refresh_auto_groups: true) }

  context "with a public event" do
    let(:post_1) { Fabricate(:post) }
    let(:event_1) { Fabricate(:event, post: post_1, raw_invitees: ["trust_level_0"]) }

    context "when a post is updated" do
      context "when the post has a valid event" do
        context "when the event markup is removed" do
          it "destroys the associated event" do
            post = create_post_with_event(user)

            expect(post.reload.event.persisted?).to eq(true)

            revisor = PostRevisor.new(post, post.topic)
            revisor.revise!(user, raw: "The event is over. Come back another day.")

            expect(post.reload.event).to be(nil)
          end
        end

        context "when event is on going" do
          let(:going_user) { Fabricate(:user) }
          let(:interested_user) { Fabricate(:user) }

          before do
            SiteSetting.editing_grace_period = 1.minute
            PostActionNotifier.enable
            SiteSetting.discourse_post_event_edit_notifications_time_extension = 180
          end

          context "when in edit grace period" do
            before do
              event_1.event_dates.first.update_columns(starts_at: 3.hours.ago, ends_at: 2.hours.ago)

              # clean state
              Notification.destroy_all
              interested_user.reload
              going_user.reload
            end

            it "sends a post revision to going invitees" do
              DiscourseEvents::Events::Invitee.create_attendance!(going_user.id, post_1.id, :going)
              DiscourseEvents::Events::Invitee.create_attendance!(
                interested_user.id,
                post_1.id,
                :interested,
              )

              expect {
                revisor = PostRevisor.new(post_1)
                revisor.revise!(
                  user,
                  { raw: post_1.raw + "\nWe are bout half way into our event!" },
                  revised_at: Time.now + 2.minutes,
                )
              }.to change { going_user.notifications.count }.by(1)

              expect(interested_user.notifications.count).to eq(0)
            end
          end

          context "when not edit grace period" do
            before { event_1.event_dates.first.update_columns(starts_at: 5.hours.ago) }

            it "doesn’t send a post revision to anyone" do
              DiscourseEvents::Events::Invitee.create_attendance!(going_user.id, post_1.id, :going)
              DiscourseEvents::Events::Invitee.create_attendance!(
                interested_user.id,
                event_1.id,
                :interested,
              )

              expect {
                revisor = PostRevisor.new(event_1.post)
                revisor.revise!(
                  user,
                  { raw: event_1.post.raw + "\nWe are bout half way into our event!" },
                  revised_at: Time.now + 2.minutes,
                )
              }.to change {
                going_user.notifications.count + interested_user.notifications.count
              }.by(0)
            end
          end

          context "with an event with recurrence" do
            before do
              freeze_time Time.utc(2020, 8, 12, 16, 32)

              event_1.update_with_params!(
                recurrence: "FREQ=WEEKLY;BYDAY=MO",
                original_starts_at: 3.hours.ago,
                original_ends_at: nil,
              )

              DiscourseEvents::Events::Invitee.create_attendance!(going_user.id, event_1.id, :going)
              DiscourseEvents::Events::Invitee.create_attendance!(
                interested_user.id,
                event_1.id,
                :interested,
              )

              event_1.reload

              # we stop processing jobs immediately at this point to prevent infinite loop
              # as future event ended job would finish now, trigger next recurrence, and other job...
              Jobs.run_later!
            end

            context "when the event ends" do
              it "sets the next dates" do
                event_1.update_with_params!(original_ends_at: Time.now)

                expect(event_1.starts_at.to_s).to eq("2020-08-19 13:32:00 UTC")
                expect(event_1.ends_at.to_s).to eq("2020-08-19 16:32:00 UTC")
              end

              it "clears status from invitees not marked as recurring" do
                going_invitee =
                  event_1.invitees.find_by(
                    status: DiscourseEvents::Events::Invitee.statuses[:going],
                  )
                interested_invitee =
                  event_1.invitees.find_by(
                    status: DiscourseEvents::Events::Invitee.statuses[:interested],
                  )

                event_1.update_with_params!(original_ends_at: Time.now)

                expect(going_invitee.reload.status).to be_nil
                expect(interested_invitee.reload.status).to be_nil
              end

              # that will be handled by new job, uncomment when finished
              it "doesn’t resend event creation notification to invitees" do
                expect { event_1.update_with_params!(original_ends_at: Time.now) }.not_to change {
                  going_user.notifications.count
                }
              end
            end
          end

          context "when updating raw_invitees" do
            let(:lurker_1) { Fabricate(:user) }
            let(:group_1) { Fabricate(:group) }

            it "doesn’t accept usernames" do
              event_1.update_with_params!(raw_invitees: [lurker_1.username])
              expect(event_1.raw_invitees).to eq(["trust_level_0"])
            end

            it "doesn’t accept another group than trust_level_0" do
              event_1.update_with_params!(raw_invitees: [group_1.name])
              expect(event_1.raw_invitees).to eq(["trust_level_0"])
            end
          end

          context "when updating status to private" do
            it "changes the status and force invitees" do
              expect(event_1.raw_invitees).to eq(["trust_level_0"])
              expect(event_1.status).to eq(DiscourseEvents::Events::Event.statuses[:public])

              event_1.update_with_params!(status: DiscourseEvents::Events::Event.statuses[:private])

              expect(event_1.raw_invitees).to eq([])
              expect(event_1.status).to eq(DiscourseEvents::Events::Event.statuses[:private])
            end
          end
        end
      end
    end

    context "when a post is created" do
      context "when the post contains one valid event" do
        context "when the acting user is admin" do
          it "creates the post event" do
            start = Time.now.utc.iso8601(3)

            post =
              PostCreator.create!(
                user,
                title: "Sell a boat party",
                raw: "[event start=\"#{start}\"]\n[/event]",
              )

            expect(post.reload.persisted?).to eq(true)
            expect(post.event.persisted?).to eq(true)
            expect(post.event.original_starts_at).to eq_time(Time.parse(start))
          end

          it "works with name attribute" do
            post = create_post_with_event(user, 'name="foo bar"').reload
            expect(post.event.name).to eq("foo bar")
          end

          it "works with url attribute" do
            url = "https://www.discourse.org"

            post = create_post_with_event(user, "url=\"#{url}\"").reload
            expect(post.event.url).to eq(url)
          end

          it "works with recording attribute" do
            Jobs.run_later!
            recording = "https://www.youtube.com/watch?v=abc123&t=10"

            post = create_post_with_event(user, "recording=\"#{recording}\"").reload
            expect(post.event.recording_url).to eq(recording)
          end

          it "works with status attribute" do
            post = create_post_with_event(user, 'status="private"').reload
            expect(post.event.status).to eq(DiscourseEvents::Events::Event.statuses[:private])
          end

          it "works with allowedGroups attribute" do
            Fabricate(:group, name: "euro")
            Fabricate(:group, name: "america")

            post = create_post_with_event(user, 'allowedGroups="euro"').reload
            expect(post.event.raw_invitees).to eq([])

            post = create_post_with_event(user, 'status="public" allowedGroups="euro"').reload
            expect(post.event.raw_invitees).to eq(%w[trust_level_0])

            post = create_post_with_event(user, 'status="standalone" allowedGroups="euro"').reload
            expect(post.event.raw_invitees).to eq([])

            post = create_post_with_event(user, 'status="private" allowedGroups="euro"').reload
            expect(post.event.raw_invitees).to eq(%w[euro])

            post =
              create_post_with_event(user, 'status="private" allowedGroups="euro,america"').reload
            expect(post.event.raw_invitees).to match_array(%w[euro america])

            post = create_post_with_event(user, 'status="private"').reload
            expect(post.event.raw_invitees).to eq([])
          end

          it "works with localised automatic group names" do
            I18n.locale = SiteSetting.default_locale = "fr"

            group = Group.find(Group::AUTO_GROUPS[:trust_level_0])
            group.update!(name: I18n.t("groups.default_names.trust_level_0"))

            post =
              create_post_with_event(user, 'status="public" allowedGroups="trust_level_0"').reload
            expect(post.event.raw_invitees).to eq(%w[trust_level_0])
          end

          it "works with reminders attribute" do
            post = create_post_with_event(user).reload
            expect(post.event.reminders).to eq(nil)

            post =
              create_post_with_event(
                user,
                'reminders="notification.1.hours,bumpTopic.-3.days"',
              ).reload
            expect(post.event.reminders).to eq("notification.1.hours,bumpTopic.-3.days")
          end

          context "with custom fields" do
            before { SiteSetting.discourse_post_event_allowed_custom_fields = "foo-bar|bar" }

            it "works with allowed custom fields" do
              post = create_post_with_event(user, 'fooBar="1"').reload
              expect(post.event.custom_fields["foo-bar"]).to eq("1")

              post = create_post_with_event(user, 'bar="2"').reload
              expect(post.event.custom_fields["bar"]).to eq("2")
            end

            it "doesn’t work with not allowed custom fields" do
              post = create_post_with_event(user, 'baz="3"').reload
              expect(post.event.custom_fields["baz"]).to eq(nil)
            end
          end

          it "creates a one-day all-day event with the same start and end date" do
            date = 1.day.from_now.strftime("%Y-%m-%d")

            post =
              PostCreator.create!(
                user,
                title: "Sell a boat party",
                raw: "[event allDay=\"true\" start=\"#{date}\" end=\"#{date}\"]\n[/event]",
              )

            event = post.reload.event
            expect(event.persisted?).to eq(true)
            expect(event.original_ends_at).to eq_time(Time.parse("#{date} 23:59:59.999999 UTC"))
          end
        end

        context "when the acting user has rights to create events" do
          let(:user_with_rights) { Fabricate(:user, refresh_auto_groups: true) }
          let(:group) { Fabricate(:group, users: [user_with_rights]) }

          before { SiteSetting.discourse_post_event_allowed_on_groups = group.id.to_s }

          it "creates the post event" do
            start = Time.now.utc.iso8601(3)

            post =
              PostCreator.create!(
                user_with_rights,
                title: "Sell a boat party",
                raw: "[event start=\"#{start}\"]\n[/event]",
              )

            expect(post.reload.persisted?).to eq(true)
            expect(post.event.persisted?).to eq(true)
            expect(post.event.original_starts_at).to eq_time(Time.parse(start))
          end
        end

        context "when the acting user doesn’t have rights to create events" do
          let(:user_without_rights) { Fabricate(:user, refresh_auto_groups: true) }
          let(:group) { Fabricate(:group, users: [user]) }

          before { SiteSetting.discourse_post_event_allowed_on_groups = group.id.to_s }

          it "raises an error" do
            start = Time.now.utc.iso8601(3)

            expect do
              PostCreator.create!(
                user_without_rights,
                title: "Sell a boat party",
                raw: "[event start=\"#{start}\"]\n[/event]",
              )
            end.to(
              raise_error(ActiveRecord::RecordNotSaved).with_message(
                I18n.t(
                  "discourse_post_event.errors.models.event.acting_user_not_allowed_to_create_event",
                ),
              ),
            )
          end
        end
      end

      context "when the post contains one invalid event" do
        context "when start is invalid" do
          it "raises an error" do
            expect do
              PostCreator.create!(
                user,
                title: "Sell a boat party",
                raw: "[event start=\"x\"]\n[/event]",
              )
            end.to(
              raise_error(ActiveRecord::RecordNotSaved).with_message(
                I18n.t(
                  "discourse_post_event.errors.models.event.start_must_be_present_and_a_valid_date",
                ),
              ),
            )
          end
        end

        context "when recurrence is invalid" do
          it "raises an error" do
            expect { create_post_with_event(user, 'recurrence="foo"') }.to raise_error(
              I18n.t(
                "discourse_post_event.errors.models.event.invalid_recurrence",
                recurrences: DiscourseEvents::Events::RRuleConfigurator::RECURRENCES.join(", "),
              ),
            )
          end
        end

        context "when start is not provided or" do
          it "is not cooked" do
            post = PostCreator.create!(user, title: "Sell a boat party", raw: <<~TXT)
                [event end=\"1\"]
                [/event]
              TXT

            expect(!post.cooked.include?("discourse-post-event")).to be(true)
          end
        end

        context "when end is provided and is invalid" do
          it "raises an error" do
            expect do
              PostCreator.create!(
                user,
                title: "Sell a boat party",
                raw: "[event start=\"#{Time.now.utc.iso8601(3)}\" end=\"d\"]\n[/event]",
              )
            end.to(
              raise_error(ActiveRecord::RecordNotSaved).with_message(
                I18n.t("discourse_post_event.errors.models.event.end_must_be_a_valid_date"),
              ),
            )
          end
        end

        context "when end is not after start" do
          let(:starts_at) { 1.day.from_now }

          def expect_rejected_end(ends_at)
            expect do
              create_post_with_event(user, "end=\"#{ends_at.utc.iso8601(3)}\"", starts_at)
            end.to(
              raise_error(ActiveRecord::RecordNotSaved).with_message(
                I18n.t("discourse_post_event.errors.models.event.ends_at_before_starts_at"),
              ),
            )
          end

          it "raises an error" do
            expect_rejected_end(starts_at)
            expect_rejected_end(starts_at - 1.hour)
          end
        end

        context "when dates omit an offset" do
          it "validates them in the event timezone" do
            post =
              PostCreator.create!(
                user,
                title: "Sell a boat party",
                raw:
                  "[event start=\"2026-06-10T18:00:00-04:00\" end=\"2026-06-10 19:00\" timezone=\"America/New_York\"]\n[/event]",
              )

            event = post.reload.event
            expect(event.persisted?).to eq(true)
            expect(event.original_ends_at).to eq_time(Time.parse("2026-06-10 23:00 UTC"))
          end
        end

        context "when description is too long" do
          it "raises an error" do
            start = 1.day.from_now.utc.iso8601(3)
            description = "a" * (DiscourseEvents::Events::Event::MAX_DESCRIPTION_LENGTH + 1)

            expect do
              PostCreator.create!(
                user,
                title: "Sell a boat party",
                raw: "[event start=\"#{start}\"]\n#{description}\n[/event]",
              )
            end.to raise_error(
              I18n.t(
                "discourse_post_event.errors.models.event.description.length",
                maximum: DiscourseEvents::Events::Event::MAX_DESCRIPTION_LENGTH,
              ),
            )
          end
        end

        context "when max attendees is invalid" do
          def expect_rejected_max_attendees(value)
            expect { create_post_with_event(user, "maxAttendees=\"#{value}\"") }.to raise_error(
              I18n.t(
                "discourse_post_event.errors.models.event.invalid_max_attendees",
                maximum: DiscourseEvents::Events::Event::MAX_ATTENDEES_LIMIT,
              ),
            )
          end

          it "raises an error" do
            expect_rejected_max_attendees("0")
            expect_rejected_max_attendees("9999999999")
            expect_rejected_max_attendees("")
          end
        end

        context "when a private event has too many allowed groups" do
          fab!(:invited_groups) do
            Fabricate.times(DiscourseEvents::Events::Event::MAX_RAW_INVITEES + 1, :group)
          end

          let(:group_names) { invited_groups.map(&:name).join(",") }

          it "raises an error" do
            expect do
              create_post_with_event(user, "status=\"private\" allowedGroups=\"#{group_names}\"")
            end.to raise_error(
              I18n.t(
                "discourse_post_event.errors.models.event.raw_invitees_length",
                count: DiscourseEvents::Events::Event::MAX_RAW_INVITEES,
              ),
            )
          end

          it "creates the event when the status is public" do
            post =
              create_post_with_event(
                user,
                "status=\"public\" allowedGroups=\"#{group_names}\"",
              ).reload

            expect(post.event.persisted?).to eq(true)
          end

          it "does not count the public group toward the limit" do
            allowed = invited_groups.take(DiscourseEvents::Events::Event::MAX_RAW_INVITEES)
            group_names = ([DiscourseEvents::Events::Event::PUBLIC_GROUP] + allowed.map(&:name))

            post =
              create_post_with_event(
                user,
                "status=\"private\" allowedGroups=\"#{group_names.join(",")}\"",
              ).reload

            expect(post.event.persisted?).to eq(true)
            expect(post.event.raw_invitees).to match_array(allowed.map(&:name))
          end
        end

        context "when recurrence until is invalid" do
          it "raises an error" do
            expect do
              create_post_with_event(user, 'recurrence="every_week" recurrenceUntil="garbage"')
            end.to raise_error(
              I18n.t(
                "discourse_post_event.errors.models.event.recurrence_until_must_be_a_valid_date",
              ),
            )
          end
        end

        context "when reminders are invalid" do
          it "raises an error" do
            expect { create_post_with_event(user, 'reminders="notification.1.fortnights"') }.to(
              raise_error(
                I18n.t(
                  "discourse_post_event.errors.models.event.invalid_reminders",
                  reminders: "notification.1.fortnights",
                ),
              ),
            )
          end
        end

        context "when url is too long" do
          it "raises an error" do
            url = "https://example.com/#{"a" * DiscourseEvents::Events::Event::MAX_URL_LENGTH}"

            expect { create_post_with_event(user, "url=\"#{url}\"") }.to raise_error(
              I18n.t(
                "discourse_post_event.errors.models.event.url.length",
                maximum: DiscourseEvents::Events::Event::MAX_URL_LENGTH,
              ),
            )
          end
        end

        context "when recording is not a web address" do
          it "raises an error" do
            expect {
              create_post_with_event(user, 'recording="javascript:alert(1)"')
            }.to raise_error(
              I18n.t("discourse_post_event.errors.models.event.invalid_recording_url"),
            )
          end
        end

        context "when location is too long" do
          it "raises an error" do
            location = "a" * (DiscourseEvents::Events::Event::MAX_LOCATION_LENGTH + 1)

            expect { create_post_with_event(user, "location=\"#{location}\"") }.to raise_error(
              I18n.t(
                "discourse_post_event.errors.models.event.location.length",
                maximum: DiscourseEvents::Events::Event::MAX_LOCATION_LENGTH,
              ),
            )
          end
        end
      end

      context "when the event sync fails unexpectedly" do
        it "logs the failure" do
          DiscourseEvents::Events::Event
            .any_instance
            .stubs(:update_with_params)
            .raises(ActiveRecord::RecordNotSaved.new("boom"))

          logger = track_log_messages { create_post_with_event(user) }

          expect(logger.errors).to include(match(/Failed to sync event/))
        end
      end

      context "when the post contains multiple events" do
        it "raises an error" do
          expect { PostCreator.create!(user, title: "Sell a boat party", raw: <<~TXT) }.to(
                [event start=\"#{Time.now.utc.iso8601(3)}\"]
                [/event]

                [event start=\"#{Time.now.utc.iso8601(3)}\"]
                [/event]
              TXT
            raise_error(ActiveRecord::RecordNotSaved).with_message(
              I18n.t("discourse_post_event.errors.models.event.only_one_event"),
            ),
          )
        end
      end
    end

    context "when a post with an event is destroyed" do
      it "sets deleted_at on the post_event" do
        expect(event_1.deleted_at).to be_nil

        PostDestroyer.new(user, event_1.post).destroy
        event_1.reload

        expect(event_1.deleted_at).to eq_time(Time.now)
      end
    end

    context "when a post with an event is recovered" do
      it "nullifies deleted_at on the post_event" do
        PostDestroyer.new(user, event_1.post).destroy

        expect(event_1.reload.deleted_at).to eq_time(Time.now)

        PostDestroyer.new(user, Post.with_deleted.find(event_1.id)).recover

        expect(event_1.reload.deleted_at).to be_nil
      end
    end
  end

  context "with a private event" do
    before { freeze_time Time.utc(2020, 8, 12, 16, 32) }

    let(:invitee_1) { Fabricate(:user) }
    let(:invitee_2) { Fabricate(:user) }
    let(:group_1) do
      Fabricate(:group).tap do |g|
        g.add(invitee_1)
        g.add(invitee_2)
        g.save!
      end
    end
    let(:post_1) { Fabricate(:post) }
    let(:event_1) do
      Fabricate(
        :event,
        post: post_1,
        status: DiscourseEvents::Events::Event.statuses[:private],
        raw_invitees: [group_1.name],
        original_starts_at: 3.hours.ago,
        original_ends_at: nil,
      )
    end

    context "with an event with recurrence" do
      let(:event_1) do
        Fabricate(
          :event,
          post: post_1,
          status: DiscourseEvents::Events::Event.statuses[:private],
          raw_invitees: [group_1.name],
          recurrence: "FREQ=WEEKLY;BYDAY=MO",
          original_starts_at: 2.hours.from_now,
          original_ends_at: nil,
        )
      end

      before do
        # we stop processing jobs immediately at this point to prevent infinite loop
        # as future event ended job would finish now, trigger next recurrence, and other job...
        Jobs.run_later!
      end

      context "when updating the end" do
        it "resends event creation notification to invitees and suggested users" do
          expect { event_1.update_with_params!(original_ends_at: 3.hours.from_now) }.to change {
            invitee_1.notifications.count + invitee_2.notifications.count
          }.by(2)
        end
      end
    end

    context "when updating raw_invitees" do
      let(:lurker_1) { Fabricate(:user) }
      let(:group_2) { Fabricate(:group) }

      it "doesn’t accept usernames" do
        expect { event_1.update_with_params!(raw_invitees: [lurker_1.username]) }.to raise_error(
          ActiveRecord::RecordInvalid,
        )
      end

      it "accepts another group than trust_level_0" do
        event_1.update_with_params!(raw_invitees: [group_2.name])
        expect(event_1.raw_invitees).to eq([group_2.name])
      end
    end

    context "when updating status to public" do
      it "changes the status and force invitees" do
        expect(event_1.raw_invitees).to eq([group_1.name])
        expect(event_1.status).to eq(DiscourseEvents::Events::Event.statuses[:private])

        event_1.update_with_params!(status: DiscourseEvents::Events::Event.statuses[:public])

        expect(event_1.raw_invitees).to eq(["trust_level_0"])
        expect(event_1.status).to eq(DiscourseEvents::Events::Event.statuses[:public])
      end
    end

    it "rejects private groups in allowedGroups" do
      moderator = Fabricate(:user, moderator: true)
      private_group = Fabricate(:group, visibility_level: Group.visibility_levels[:owners])

      expect {
        create_post_with_event(moderator, "allowedGroups='#{private_group.name}'")
      }.to raise_error(ActiveRecord::RecordNotSaved)
    end

    it "rejects non-existent groups in allowedGroups" do
      moderator = Fabricate(:user, moderator: true)

      expect {
        create_post_with_event(moderator, "allowedGroups='non-existent_group_name'")
      }.to raise_error(ActiveRecord::RecordNotSaved)
    end

    it "rejects public groups with private members in allowedGroups" do
      moderator = Fabricate(:user, moderator: true)
      public_group_with_private_members =
        Fabricate(
          :group,
          visibility_level: Group.visibility_levels[:public],
          members_visibility_level: Group.visibility_levels[:owners],
        )

      expect {
        create_post_with_event(
          moderator,
          "allowedGroups='#{public_group_with_private_members.name}'",
        )
      }.to raise_error(ActiveRecord::RecordNotSaved)
    end
  end

  context "with holiday events" do
    let(:calendar_post) { create_post(raw: "[calendar]\n[/calendar]") }

    before do
      SiteSetting.holiday_calendar_topic_id = calendar_post.topic_id
      SiteSetting.enable_user_status = true
    end

    context "when adding a post with an event" do
      it "sets holiday user status" do
        freeze_time Time.utc(2018, 6, 5, 10, 30)

        raw = 'Vacation [date="2018-06-05" time="10:20:00"] to [date="2018-06-06" time="10:20:00"]'
        post = create_post(raw: raw, topic: calendar_post.topic)

        status = post.user.user_status
        expect(status).to be_present
        expect(status.description).to eq(I18n.t("discourse_events.holiday_status.description"))
        expect(status.emoji).to eq(SiteSetting.holiday_status_emoji)
        expect(status.ends_at).to eq_time(Time.utc(2018, 6, 6, 10, 20))
      end

      it "doesn't set holiday user status if user already has custom user status" do
        freeze_time Time.utc(2018, 6, 5, 10, 30)

        # user sets a custom status
        custom_status = { description: "I am working on holiday", emoji: "construction_worker_man" }
        user.set_status!(custom_status[:description], custom_status[:emoji])

        raw = 'Vacation [date="2018-06-05" time="10:20:00"] to [date="2018-06-06" time="10:20:00"]'
        post = create_post(raw: raw, topic: calendar_post.topic, user: user)

        # a holiday status wasn't set:
        status = post.user.user_status
        expect(status).to be_present
        expect(status.description).to eq(custom_status[:description])
        expect(status.emoji).to eq(custom_status[:emoji])
      end

      context "when using multiple calendars" do
        let(:regular_calendar_post) { create_post(raw: "[calendar]\n[/calendar]") }

        it "doesn't set holiday user status for a non-holiday calendar" do
          freeze_time Time.utc(2018, 6, 5, 10, 30)

          raw = 'Meeting [date="2018-06-05" time="10:20:00"] to [date="2018-06-06" time="10:20:00"]'
          post = create_post(raw: raw, topic: regular_calendar_post.topic, user: user)

          # a holiday status wasn't set:
          expect(post.user.user_status).to be_nil
        end
      end

      context "when custom emoji is set" do
        custom_emoji = "palm_tree"

        before { SiteSetting.holiday_status_emoji = custom_emoji }

        it "sets holiday user status with custom emoji" do
          freeze_time Time.utc(2018, 6, 5, 10, 30)

          raw =
            'Vacation [date="2018-06-05" time="10:20:00"] to [date="2018-06-06" time="10:20:00"]'
          post = create_post(raw: raw, topic: calendar_post.topic)

          status = post.user.user_status
          expect(status).to be_present
          expect(status.description).to eq(I18n.t("discourse_events.holiday_status.description"))
          expect(status.emoji).to eq(custom_emoji)
          expect(status.ends_at).to eq_time(Time.utc(2018, 6, 6, 10, 20))
        end
      end

      context "when custom emoji is blank" do
        before { SiteSetting.holiday_status_emoji = "" }

        it "sets holiday user status with the default emoji" do
          freeze_time Time.utc(2018, 6, 5, 10, 30)

          raw =
            'Vacation [date="2018-06-05" time="10:20:00"] to [date="2018-06-06" time="10:20:00"]'
          post = create_post(raw: raw, topic: calendar_post.topic)

          status = post.user.user_status
          expect(status).to be_present
          expect(status.description).to eq(I18n.t("discourse_events.holiday_status.description"))
          expect(status.emoji).to eq("date")
          expect(status.ends_at).to eq_time(Time.utc(2018, 6, 6, 10, 20))
        end
      end
    end

    context "when updating event dates" do
      it "sets holiday user status" do
        freeze_time Time.utc(2018, 6, 5, 10, 30)
        today = "2018-06-05"
        tomorrow = "2018-06-06"

        raw = "Vacation [date='#{tomorrow}']"
        post = create_post(raw: raw, topic: calendar_post.topic)
        expect(post.user.user_status).to be_blank

        PostRevisor.new(post).revise!(post.user, { raw: "Vacation [date='#{today}']" })
        post.reload

        status = post.user.user_status
        expect(status).to be_present
        expect(status.description).to eq(I18n.t("discourse_events.holiday_status.description"))
        expect(status.emoji).to eq(SiteSetting.holiday_status_emoji)
        expect(status.ends_at).to eq_time(Time.utc(2018, 6, 6, 0, 0))
      end

      it "doesn't set holiday user status if user already has custom user status" do
        freeze_time Time.utc(2018, 6, 5, 10, 30)
        today = "2018-06-05"
        tomorrow = "2018-06-06"

        raw = "Vacation [date='#{tomorrow}']"
        post = create_post(raw: raw, topic: calendar_post.topic)
        expect(post.user.user_status).to be_blank

        # user sets a custom status
        custom_status = { description: "I am working on holiday", emoji: "construction_worker_man" }
        post.user.set_status!(custom_status[:description], custom_status[:emoji])

        PostRevisor.new(post).revise!(post.user, { raw: "Vacation [date='#{today}']" })
        post.reload

        # a holiday status wasn't set:
        status = post.user.user_status
        expect(status).to be_present
        expect(status.description).to eq(custom_status[:description])
        expect(status.emoji).to eq(custom_status[:emoji])
      end
    end

    context "when deleting a post with an event" do
      it "clears user status that was previously set by the calendar plugin" do
        freeze_time Time.utc(2018, 6, 5, 10, 30)

        raw = 'Vacation [date="2018-06-05" time="10:20:00"] to [date="2018-06-06" time="10:20:00"]'
        post = create_post(raw: raw, topic: calendar_post.topic)
        Jobs::DiscourseCalendar::UpdateHolidayUsernames.new.execute(nil)

        # the job has set the holiday status:
        status = post.user.user_status
        expect(status).to be_present
        expect(status.description).to eq(I18n.t("discourse_events.holiday_status.description"))
        expect(status.emoji).to eq(SiteSetting.holiday_status_emoji)
        expect(status.ends_at).to eq_time(Time.utc(2018, 6, 6, 10, 20))

        # after destroying the post the holiday status disappears:
        PostDestroyer.new(user, post).destroy
        post.user.reload

        expect(post.user.user_status).to be_nil
      end

      it "doesn't clear user status that wasn't set by the calendar plugin" do
        freeze_time Time.utc(2018, 6, 5, 10, 30)

        raw = 'Vacation [date="2018-06-05" time="10:20:00"] to [date="2018-06-06" time="10:20:00"]'
        post = create_post(raw: raw, topic: calendar_post.topic)
        Jobs::DiscourseCalendar::UpdateHolidayUsernames.new.execute(nil)

        # the job has set the holiday status:
        status = post.user.user_status
        expect(status).to be_present
        expect(status.description).to eq(I18n.t("discourse_events.holiday_status.description"))
        expect(status.emoji).to eq(SiteSetting.holiday_status_emoji)
        expect(status.ends_at).to eq_time(Time.utc(2018, 6, 6, 10, 20))

        # user sets a custom status
        custom_status = { description: "I am working on holiday", emoji: "construction_worker_man" }
        post.user.set_status!(custom_status[:description], custom_status[:emoji])

        # the status that was set by user doesn't disappear after destroying the post:
        PostDestroyer.new(user, post).destroy
        post.user.reload

        status = post.user.user_status
        expect(status).to be_present
        expect(status.description).to eq(custom_status[:description])
        expect(status.emoji).to eq(custom_status[:emoji])
      end
    end
  end

  describe "timezone handling" do
    before { freeze_time Time.utc(2022, 7, 24, 13, 00) }

    it "stores the correct information in the database" do
      expected_datetime = ActiveSupport::TimeZone["Australia/Sydney"].parse("2022-07-24 14:01")

      post =
        PostCreator.create!(
          user,
          title: "Beach party",
          raw: "[event start='2022-07-24 14:01' timezone='Australia/Sydney']\n[/event]",
        ).reload

      expect(post.event.timezone).to eq("Australia/Sydney")
      expect(post.event.original_starts_at).to eq_time(expected_datetime)
      expect(post.event.starts_at).to eq_time(expected_datetime)
      expect(post.event.event_dates.first.starts_at).to eq_time(expected_datetime)
    end

    it "raises an error for invalid timezone" do
      expect {
        PostCreator.create!(
          user,
          title: "Beach party",
          raw: "[event start='2022-07-24 14:01' timezone='Westeros/Winterfell']\n[/event]",
        )
      }.to raise_error(I18n.t("discourse_post_event.errors.models.event.invalid_timezone"))
    end

    it "handles simple weekly recurrence correctly" do
      # Friday in Aus, Thursday in UTC
      expected_original_datetime =
        ActiveSupport::TimeZone["Australia/Sydney"].parse("2022-07-01 09:01")
      expected_next_datetime = ActiveSupport::TimeZone["Australia/Sydney"].parse("2022-07-29 09:01")

      post =
        PostCreator.create!(
          user,
          title: "Friday beach party",
          raw:
            "[event start='2022-07-01 09:01' end='2022-07-01 10:01' timezone='Australia/Sydney' recurrence='every_week']\n[/event]",
        ).reload

      expect(post.event.timezone).to eq("Australia/Sydney")
      expect(post.event.original_starts_at).to eq_time(expected_original_datetime)
      expect(post.event.starts_at).to eq_time(expected_next_datetime)
    end

    it "handles recurrence across daylight saving" do
      # DST starts on 27th March. Original datetime is before that. Expecting
      # local time to be correct after the DST change
      expected_original_datetime = ActiveSupport::TimeZone["Europe/Paris"].parse("2022-03-20 09:01")
      expected_next_datetime = ActiveSupport::TimeZone["Europe/Paris"].parse("2022-07-25 09:01")

      post =
        PostCreator.create!(
          user,
          title: "Friday beach party",
          raw:
            "[event start='2022-03-20 09:01' end='2022-03-20 10:01' timezone='Europe/Paris' recurrence='every_day']\n[/event]",
        ).reload

      expect(post.event.timezone).to eq("Europe/Paris")
      expect(post.event.original_starts_at).to eq_time(expected_original_datetime)
      expect(post.event.starts_at).to eq_time(expected_next_datetime)
    end

    it "handles showLocalTime with non-recurring events" do
      expected_datetime = ActiveSupport::TimeZone["Europe/Prague"].parse("2025-09-07 18:30")

      post =
        PostCreator.create!(
          user,
          title: "Prague dinner",
          raw:
            "[event start='2025-09-07 18:30' end='2025-09-07 21:00' timezone='Europe/Prague' showLocalTime='true']\n[/event]",
        ).reload

      expect(post.event.timezone).to eq("Europe/Prague")
      expect(post.event.show_local_time).to eq(true)
      expect(post.event.original_starts_at).to eq_time(expected_datetime)

      serializer =
        DiscourseEvents::Events::BasicEventSerializer.new(post.event, scope: Guardian.new(user))
      serialized = serializer.as_json

      # Should return floating time (no timezone info)
      expect(serialized[:basic_event][:starts_at]).to eq("2025-09-07T18:30:00")
      expect(serialized[:basic_event][:ends_at]).to eq("2025-09-07T21:00:00")
    end
  end
end