/*
    * SPDX-FileCopyrightText: Copyright (c) 2013-2025 Yegor Bugayenko
    * SPDX-License-Identifier: MIT
    */
   package com.jcabi.github;
   
   import java.io.IOException;
   import org.apache.commons.lang3.RandomStringUtils;
   import org.hamcrest.MatcherAssert;
  import org.hamcrest.Matchers;
  import org.junit.jupiter.api.AfterAll;
  import org.junit.jupiter.api.BeforeAll;
  import org.junit.jupiter.api.Test;
  
  /**
   * Integration test for {@link RtReleaseAssets}.
   * @since 0.8
   * @checkstyle MultipleStringLiteralsCheck (200 lines)
   */
  @OAuthScope(OAuthScope.Scope.REPO)
  @SuppressWarnings("PMD.AvoidDuplicateLiterals")
  final class RtReleaseAssetsITCase {
  
      /**
       * Test repos.
       */
      private static Repos repos;
  
      /**
       * Test repo.
       */
      private static Repo repo;
  
      /**
       * RepoRule.
       * @checkstyle VisibilityModifierCheck (3 lines)
       */
      private static RepoRule rule = new RepoRule();
  
      /**
       * Set up test fixtures.
       */
      @BeforeAll
      static void setUp() throws IOException {
          final GitHub github = GitHubIT.connect();
          RtReleaseAssetsITCase.repos = github.repos();
          RtReleaseAssetsITCase.repo = RtReleaseAssetsITCase.rule.repo(RtReleaseAssetsITCase.repos);
          RtReleaseAssetsITCase.repo.releases().create(
              RandomStringUtils.secure().nextAlphanumeric(10)
          );
      }
  
      /**
       * Tear down test fixtures.
       */
      @AfterAll
      static void tearDown() throws IOException {
          if (RtReleaseAssetsITCase.repos != null && RtReleaseAssetsITCase.repo != null) {
              RtReleaseAssetsITCase.repos.remove(RtReleaseAssetsITCase.repo.coordinates());
          }
      }
  
      @Test
      void uploadsAssets() throws IOException {
          final Releases releases = RtReleaseAssetsITCase.repo.releases();
          final Release release = releases
              .create(RandomStringUtils.secure().nextAlphanumeric(10));
          final ReleaseAssets assets = release.assets();
          try {
              final String name = "upload.txt";
              final ReleaseAsset uploaded = assets.upload(
                  "upload".getBytes(),
                  "text/plain",
                  name
              );
              MatcherAssert.assertThat(
                  "Values are not equal",
                  uploaded.json().getString("name"),
                  Matchers.is(name)
              );
          } finally {
              releases.remove(release.number());
          }
      }
  
      @Test
      void uploadsTwoAssets() throws IOException {
          final Releases releases = RtReleaseAssetsITCase.repo.releases();
          final Release release = releases
              .create(RandomStringUtils.secure().nextAlphanumeric(10));
          final ReleaseAssets assets = release.assets();
          try {
              final String name = "upload.txt";
              final ReleaseAsset uploaded = assets.upload(
                  "upload".getBytes(),
                  "text/plain",
                  name
              );
              MatcherAssert.assertThat(
                 "Values are not equal",
                 uploaded.json().getString("name"),
                 Matchers.is(name)
             );
             final String othername = "upload2.txt";
             final ReleaseAsset other = assets.upload(
                 "upload2".getBytes(),
                 "text/plain",
                 othername
             );
             MatcherAssert.assertThat(
                 "Values are not equal",
                 other.json().getString("name"),
                 Matchers.is(othername)
             );
         } finally {
             releases.remove(release.number());
         }
     }
 
     @Test
     void uploadsSameAssetInTwoReleases() throws IOException {
         final Releases releases = RtReleaseAssetsITCase.repo.releases();
         final Release release = releases.create(
             RandomStringUtils.secure().nextAlphanumeric(10)
         );
         final Release otherrelease = releases.create(
             RandomStringUtils.secure().nextAlphanumeric(10)
         );
         final ReleaseAssets assets = release.assets();
         final ReleaseAssets otherassets = otherrelease.assets();
         try {
             final String name = "upload.txt";
             final ReleaseAsset uploaded = assets.upload(
                 "upload".getBytes(),
                 "text/plain",
                 name
             );
             MatcherAssert.assertThat(
                 "Values are not equal",
                 uploaded.json().getString("name"),
                 Matchers.is(name)
             );
             final ReleaseAsset other = otherassets.upload(
                 "upload".getBytes(),
                 "text/plain",
                 name
             );
             MatcherAssert.assertThat(
                 "Values are not equal",
                 other.json().getString("name"),
                 Matchers.is(name)
             );
         } finally {
             releases.remove(release.number());
             releases.remove(otherrelease.number());
         }
     }
 
     @Test
     void fetchesAssets() throws IOException {
         final Releases releases = RtReleaseAssetsITCase.repo.releases();
         final Release release = releases
             .create(RandomStringUtils.secure().nextAlphanumeric(10));
         final ReleaseAssets assets = release.assets();
         try {
             final ReleaseAsset uploaded = assets.upload(
                 "fetch".getBytes(),
                 "text/plain",
                 "fetch.txt"
             );
             MatcherAssert.assertThat(
                 "Values are not equal",
                 assets.get(uploaded.number()),
                 Matchers.is(uploaded)
             );
         } finally {
             releases.remove(release.number());
         }
     }
 
     @Test
     void iteratesAssets() throws IOException {
         final Releases releases = RtReleaseAssetsITCase.repo.releases();
         final Release release = releases
             .create(RandomStringUtils.secure().nextAlphanumeric(10));
         final ReleaseAssets assets = release.assets();
         try {
             final ReleaseAsset first = assets.upload(
                 "first".getBytes(),
                 "text/plain",
                 "first.txt"
             );
             final ReleaseAsset second = assets.upload(
                 "second".getBytes(),
                 "text/plain",
                 "second.txt"
             );
             MatcherAssert.assertThat(
                 "Assertion failed",
                 assets.iterate(),
                 Matchers.contains(first, second)
             );
         } finally {
             releases.remove(release.number());
         }
     }
 
     @Test
     void returnsNoAssets() throws IOException {
         final Releases releases = RtReleaseAssetsITCase.repo.releases();
         final Release release = releases
             .create(RandomStringUtils.secure().nextAlphanumeric(10));
         final ReleaseAssets assets = release.assets();
         try {
             MatcherAssert.assertThat(
                 "Collection is not empty",
                 assets.iterate(),
                 Matchers.emptyIterable()
             );
         } finally {
             releases.remove(release.number());
         }
     }
 
 }