/*
    * SPDX-FileCopyrightText: Copyright (c) 2013-2025 Yegor Bugayenko
    * SPDX-License-Identifier: MIT
    */
   package com.jcabi.github.mock;
   
   import com.google.common.base.Optional;
   import com.jcabi.github.Event;
   import java.io.IOException;
  import java.util.Iterator;
  import org.hamcrest.MatcherAssert;
  import org.hamcrest.Matchers;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test case for {@link MkIssueEvents}.
   * @since 0.23
   */
  @SuppressWarnings("PMD.AvoidDuplicateLiterals")
  final class MkIssueEventsTest {
      /**
       * Absent optional string.
       */
      private static final Optional<String> ABSENT_STR = Optional.absent();
  
      /**
       * MkIssueEvents can create issue events.
       * @throws Exception If some problem inside
       */
      @Test
      void createsIssueEvent() throws Exception {
          final MkIssueEvents events = MkIssueEventsTest.issueEvents();
          final String login = "jack";
          final String type = "locked";
          final long before = MkIssueEventsTest.now();
          final Event.Smart event = new Event.Smart(
              events.create(
                  type,
                  2,
                  login,
                  MkIssueEventsTest.ABSENT_STR
              )
          );
          final long after = MkIssueEventsTest.now();
          MatcherAssert.assertThat(
              "Values are not equal",
              event.type(),
              Matchers.equalTo(type)
          );
          MatcherAssert.assertThat(
              "Values are not equal",
              event.author().login(),
              Matchers.equalTo(login)
          );
          MatcherAssert.assertThat(
              "Values are not equal",
              event.url().toString(),
              Matchers.equalTo(
                  String.format(
                      // @checkstyle LineLength (1 line)
                      "https://api.jcabi-github.invalid/repos/jeff/%s/issues/events/1",
                      events.repo().coordinates().repo()
                  )
              )
          );
          MatcherAssert.assertThat(
              "Value is not greater than expected",
              event.createdAt().getTime(),
              Matchers.greaterThanOrEqualTo(before)
          );
          MatcherAssert.assertThat(
              "Value is not less than expected",
              event.createdAt().getTime(),
              Matchers.lessThanOrEqualTo(after)
          );
      }
  
      /**
       * MkIssueEvents can create an issue event with a label attribute.
       * @throws Exception If some problem inside
       */
      @Test
      void createsIssueEventWithLabel() throws Exception {
          final MkIssueEvents events = MkIssueEventsTest.issueEvents();
          final String label = "my label";
          final Event.Smart event = new Event.Smart(
              events.create(
                  "labeled",
                  2,
                  "samuel",
                  Optional.of(label)
              )
          );
          MatcherAssert.assertThat(
              "Values are not equal",
              event.label().get().name(),
              Matchers.equalTo(label)
          );
      }
 
     /**
      * MkIssueEvents can get a single issue event.
      * @throws Exception If some problem inside
      */
     @Test
     void getsIssueEvent() throws Exception {
         final MkIssueEvents events = MkIssueEventsTest.issueEvents();
         final String type = "unlocked";
         final String login = "jill";
         final int eventnum = events.create(
             type,
             2,
             login,
             MkIssueEventsTest.ABSENT_STR
         ).number();
         final Event.Smart event = new Event.Smart(events.get(eventnum));
         MatcherAssert.assertThat(
             "Values are not equal",
             event.number(),
             Matchers.equalTo(eventnum)
         );
         MatcherAssert.assertThat(
             "Values are not equal",
             event.type(),
             Matchers.equalTo(type)
         );
         MatcherAssert.assertThat(
             "Values are not equal",
             event.author().login(),
             Matchers.equalTo(login)
         );
     }
 
     /**
      * MkIssueEvents can iterate over issue events in correct order.
      * @throws Exception If some problem inside
      */
     @Test
     void iteratesIssueEvents() throws Exception {
         final MkIssueEvents events = MkIssueEventsTest.issueEvents();
         final Event first = events.create(
             "closed",
             3,
             "john",
             MkIssueEventsTest.ABSENT_STR
         );
         final Event second = events.create(
             "reopened",
             3,
             "jane",
             MkIssueEventsTest.ABSENT_STR
         );
         MatcherAssert.assertThat(
             "Collection size is incorrect",
             events.iterate(),
             Matchers.iterableWithSize(2)
         );
         final Iterator<Event> iter = events.iterate().iterator();
         MatcherAssert.assertThat(
             "Values are not equal",
             iter.next(),
             Matchers.equalTo(first)
         );
         MatcherAssert.assertThat(
             "Values are not equal",
             iter.next(),
             Matchers.equalTo(second)
         );
     }
 
     /**
      * Create an MkIssueEvents to work with.
      * Can't use normal IssueEvents because we need the mock-only
      * {@link MkIssueEvents#create(String, int, String, Optional)} method.
      * @return MkIssueEvents
      */
     private static MkIssueEvents issueEvents() throws IOException {
         return MkIssueEvents.class.cast(
             new MkGitHub().randomRepo().issueEvents()
         );
     }
 
     /**
      * Obtains the current time.
      * @return Current time (in milliseconds since epoch) truncated to the nearest second
      */
     private static long now() {
         final long sinceepoch = System.currentTimeMillis();
         return sinceepoch - sinceepoch % 1000;
     }
 }