content: package org.apache.archiva.webdav;
  
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *  http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  
  import com.gargoylesoftware.htmlunit.WebRequest;
  import com.gargoylesoftware.htmlunit.WebResponse;
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Test;
  
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.attribute.FileTime;
  
  /**
   * RepositoryServlet Tests, Proxied, Get of resources that are not artifacts or metadata, with varying policy settings.
   * 
   */
  public class RepositoryServletProxiedPassthroughTest
      extends AbstractRepositoryServletProxiedTestCase
  {
      private static final String CONTENT_SHA1 = "2aab0a51c04c9023636852f3e63a68034ba10142";
  
      private static final String PATH_SHA1 = "org/apache/archiva/test/1.0/test-1.0.jar.sha1";
  
      private static final String CONTENT_ASC =
          "-----BEGIN PGP SIGNATURE-----\n" + "Version: GnuPG v1.4.8 (Darwin)\n" + "\n"
              + "iEYEABECAAYFAkiAIVgACgkQxbsDNW2stZZjyACeK3LW+ZDeawCyJj4XgvUaJkNh\n"
              + "qIEAoIUiijY4Iw82RWOT75Rt3yZuY6ZI\n" + "=WLkm\n" + "-----END PGP SIGNATURE-----\n";
  
      private static final String PATH_ASC = "org/apache/archiva/test/1.0/test-1.0.jar.asc";
  
      @Before
      public void setup()
          throws Exception
      {
          super.setUp();
      }
  
      @After
      @Override
      public void tearDown()
          throws Exception
      {
          super.tearDown();
      }
  
      @Test
      public void testGetProxiedManagedNewerSha1()
          throws Exception
      {
          assertGetProxiedResource( EXPECT_MANAGED_CONTENTS, HAS_MANAGED_COPY, ( NEWER * OVER_ONE_DAY ), PATH_SHA1,
                                    CONTENT_SHA1 );
      }
  
      @Test
      public void testGetProxiedManagedOlderSha1()
          throws Exception
      {
          assertGetProxiedResource( EXPECT_REMOTE_CONTENTS, HAS_MANAGED_COPY, ( OLDER * OVER_ONE_DAY ), PATH_SHA1,
                                    CONTENT_SHA1 );
      }
  
      @Test
      public void testGetProxiedNoManagedContentSha1()
          throws Exception
      {
          assertGetProxiedResource( EXPECT_REMOTE_CONTENTS, NO_MANAGED_COPY, PATH_SHA1, CONTENT_SHA1 );
      }
  
      @Test
      public void testGetProxiedEqualSha1()
          throws Exception
      {
          assertGetProxiedResource( EXPECT_MANAGED_CONTENTS, HAS_MANAGED_COPY, PATH_SHA1, CONTENT_SHA1 );
      }
  
      @Test
      public void testGetProxiedManagedNewerAsc()
          throws Exception
      {
          assertGetProxiedResource( EXPECT_MANAGED_CONTENTS, HAS_MANAGED_COPY, ( NEWER * OVER_ONE_DAY ), PATH_ASC,
                                    CONTENT_ASC );
      }
  
      @Test
      public void testGetProxiedManagedOlderAsc()
          throws Exception
      {
          assertGetProxiedResource( EXPECT_REMOTE_CONTENTS, HAS_MANAGED_COPY, ( OLDER * OVER_ONE_DAY ), PATH_ASC,
                                    CONTENT_ASC );
      }
  
      @Test
      public void testGetProxiedNoManagedContentAsc()
          throws Exception
      {
          assertGetProxiedResource( EXPECT_REMOTE_CONTENTS, NO_MANAGED_COPY, PATH_ASC, CONTENT_ASC );
      }
  
      @Test
      public void testGetProxiedEqualAsc()
          throws Exception
      {
          assertGetProxiedResource( EXPECT_MANAGED_CONTENTS, HAS_MANAGED_COPY, PATH_ASC, CONTENT_ASC );
      }
  
      private void assertGetProxiedResource( int expectation, boolean hasManagedCopy, String path, String content )
          throws Exception
      {
          assertGetProxiedResource( expectation, hasManagedCopy, 0, path, content );
      }
  
      private void assertGetProxiedResource( int expectation, boolean hasManagedCopy, long deltaManagedToRemoteTimestamp,
                                             String path, String contents )
          throws Exception
      {
          // --- Setup
          setupCentralRemoteRepo();
          setupCleanInternalRepo();
          saveConfiguration();
  
          String expectedRemoteContents = contents;
          String expectedManagedContents = null;
          Path remoteFile = populateRepo( remoteCentral, path, expectedRemoteContents );
  
          if ( hasManagedCopy )
          {
              expectedManagedContents = contents;
              Path managedFile = populateRepo( repoRootInternal, path, expectedManagedContents );
              Files.setLastModifiedTime( managedFile, FileTime.fromMillis( Files.getLastModifiedTime( remoteFile ).toMillis() + deltaManagedToRemoteTimestamp ));
          }
  
          setupConnector( REPOID_INTERNAL, remoteCentral );
          saveConfiguration();
  
          // --- Execution
          // process the response code later, not via an exception.
          //HttpUnitOptions.setExceptionsThrownOnErrorStatus( false );
  
          WebRequest request = new GetMethodWebRequest( "http://machine.com/repository/internal/" + path );
          WebResponse response = getServletUnitClient().getResponse( request );
  
          // --- Verification
  
          switch ( expectation )
          {
              case EXPECT_MANAGED_CONTENTS:
                  assertResponseOK( response );
                  assertTrue( "Invalid Test Case: Can't expect managed contents with "
                      + "test that doesn't have a managed copy in the first place.", hasManagedCopy );
                  assertEquals( "Expected managed file contents", expectedManagedContents, response.getContentAsString() );
                  break;
              case EXPECT_REMOTE_CONTENTS:
                  assertResponseOK( response, path );
                  assertEquals( "Expected remote file contents", expectedRemoteContents, response.getContentAsString() );
                  break;
              case EXPECT_NOT_FOUND:
                  assertResponseNotFound( response );
                  assertManagedFileNotExists( repoRootInternal, path );
                  break;
          }
      }
  }
  