org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/HookMessageTest.java

   1 /*
   2  * Copyright (C) 2010, Google Inc.
   3  * and other copyright owners as documented in the project's IP log.
   4  *
   5  * This program and the accompanying materials are made available
   6  * under the terms of the Eclipse Distribution License v1.0 which
   7  * accompanies this distribution, is reproduced below, and is
   8  * available at http://www.eclipse.org/org/documents/edl-v10.php
   9  *
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or
  13  * without modification, are permitted provided that the following
  14  * conditions are met:
  15  *
  16  * - Redistributions of source code must retain the above copyright
  17  *   notice, this list of conditions and the following disclaimer.
  18  *
  19  * - Redistributions in binary form must reproduce the above
  20  *   copyright notice, this list of conditions and the following
  21  *   disclaimer in the documentation and/or other materials provided
  22  *   with the distribution.
  23  *
  24  * - Neither the name of the Eclipse Foundation, Inc. nor the
  25  *   names of its contributors may be used to endorse or promote
  26  *   products derived from this software without specific prior
  27  *   written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  30  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  31  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  32  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  33  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  34  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  35  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  36  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  37  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  38  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  40  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  41  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  42  */
  43
  44 package org.eclipse.jgit.http.test;
  45
  46 import java.util.Collection;
  47 import java.util.Collections;
  48 import java.util.List;
  49
  50 import javax.servlet.http.HttpServletRequest;
  51
  52 import org.eclipse.jetty.servlet.ServletContextHandler;
  53 import org.eclipse.jetty.servlet.ServletHolder;
  54 import org.eclipse.jgit.errors.RepositoryNotFoundException;
  55 import org.eclipse.jgit.http.server.GitServlet;
  56 import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory;
  57 import org.eclipse.jgit.http.server.resolver.RepositoryResolver;
  58 import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
  59 import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
  60 import org.eclipse.jgit.http.test.util.AccessEvent;
  61 import org.eclipse.jgit.http.test.util.HttpTestCase;
  62 import org.eclipse.jgit.junit.TestRepository;
  63 import org.eclipse.jgit.lib.Constants;
  64 import org.eclipse.jgit.lib.NullProgressMonitor;
  65 import org.eclipse.jgit.lib.ObjectId;
  66 import org.eclipse.jgit.lib.Repository;
  67 import org.eclipse.jgit.lib.RepositoryConfig;
  68 import org.eclipse.jgit.revwalk.RevBlob;
  69 import org.eclipse.jgit.revwalk.RevCommit;
  70 import org.eclipse.jgit.transport.PreReceiveHook;
  71 import org.eclipse.jgit.transport.PushResult;
  72 import org.eclipse.jgit.transport.ReceiveCommand;
  73 import org.eclipse.jgit.transport.ReceivePack;
  74 import org.eclipse.jgit.transport.RemoteRefUpdate;
  75 import org.eclipse.jgit.transport.Transport;
  76 import org.eclipse.jgit.transport.URIish;
  77
  78 public class HookMessageTest extends HttpTestCase {
  79         private Repository remoteRepository;
  80
  81         private URIish remoteURI;
  82
  83         protected void setUp() throws Exception {
  84                 super.setUp();
  85
  86                 final TestRepository src = createTestRepository();
  87                 final String srcName = src.getRepository().getDirectory().getName();
  88
  89                 ServletContextHandler app = server.addContext("/git");
  90                 GitServlet gs = new GitServlet();
  91                 gs.setRepositoryResolver(new RepositoryResolver() {
  92                         public Repository open(HttpServletRequest req, String name)
  93                                         throws RepositoryNotFoundException,
  94                                         ServiceNotEnabledException {
  95                                 if (!name.equals(srcName))
  96                                         throw new RepositoryNotFoundException(name);
  97
  98                                 final Repository db = src.getRepository();
  99                                 db.incrementOpen();
 100                                 return db;
 101                         }
 102                 });
 103                 gs.setReceivePackFactory(new DefaultReceivePackFactory() {
 104                         public ReceivePack create(HttpServletRequest req, Repository db)
 105                                         throws ServiceNotEnabledException,
 106                                         ServiceNotAuthorizedException {
 107                                 ReceivePack recv = super.create(req, db);
 108                                 recv.setPreReceiveHook(new PreReceiveHook() {
 109                                         public void onPreReceive(ReceivePack rp,
 110                                                         Collection<ReceiveCommand> commands) {
 111                                                 rp.sendMessage("message line 1");
 112                                                 rp.sendError("no soup for you!");
 113                                                 rp.sendMessage("come back next year!");
 114                                         }
 115                                 });
 116                                 return recv;
 117                         }
 118
 119                 });
 120                 app.addServlet(new ServletHolder(gs), "/*");
 121
 122                 server.setUp();
 123
 124                 remoteRepository = src.getRepository();
 125                 remoteURI = toURIish(app, srcName);
 126
 127                 RepositoryConfig cfg = remoteRepository.getConfig();
 128                 cfg.setBoolean("http", null, "receivepack", true);
 129                 cfg.save();
 130         }
 131
 132         public void testPush_CreateBranch() throws Exception {
 133                 final TestRepository src = createTestRepository();
 134                 final RevBlob Q_txt = src.blob("new text");
 135                 final RevCommit Q = src.commit().add("Q", Q_txt).create();
 136                 final Repository db = src.getRepository();
 137                 final String dstName = Constants.R_HEADS + "new.branch";
 138                 Transport t;
 139                 PushResult result;
 140
 141                 t = Transport.open(db, remoteURI);
 142                 try {
 143                         final String srcExpr = Q.name();
 144                         final boolean forceUpdate = false;
 145                         final String localName = null;
 146                         final ObjectId oldId = null;
 147
 148                         RemoteRefUpdate update = new RemoteRefUpdate(src.getRepository(),
 149                                         srcExpr, dstName, forceUpdate, localName, oldId);
 150                         result = t.push(NullProgressMonitor.INSTANCE, Collections
 151                                         .singleton(update));
 152                 } finally {
 153                         t.close();
 154                 }
 155
 156                 assertTrue(remoteRepository.hasObject(Q_txt));
 157                 assertNotNull("has " + dstName, remoteRepository.getRef(dstName));
 158                 assertEquals(Q, remoteRepository.getRef(dstName).getObjectId());
 159                 fsck(remoteRepository, Q);
 160
 161                 List<AccessEvent> requests = getRequests();
 162                 assertEquals(2, requests.size());
 163
 164                 AccessEvent service = requests.get(1);
 165                 assertEquals("POST", service.getMethod());
 166                 assertEquals(join(remoteURI, "git-receive-pack"), service.getPath());
 167                 assertEquals(200, service.getStatus());
 168
 169                 assertEquals("message line 1\n" //
 170                                 + "error: no soup for you!\n" //
 171                                 + "come back next year!\n", //
 172                                 result.getMessages());
 173         }
 174 }