content: /**
   * ﻿Copyright (C) 2007 - 2019 52°North Initiative for Geospatial Open Source
   * Software GmbH
   *
   * This program is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 as published
   * by the Free Software Foundation.
   *
   * If the program is linked with libraries which are licensed under one of
   * the following licenses, the combination of the program with the linked
   * library is not considered a "derivative work" of the program:
   *
   *       • Apache License, version 2.0
   *       • Apache Software License, version 1.0
   *       • GNU Lesser General Public License, version 3
   *       • Mozilla Public License, versions 1.0, 1.1 and 2.0
   *       • Common Development and Distribution License (CDDL), version 1.0
   *
   * Therefore the distribution of the program linked with libraries licensed
   * under the aforementioned licenses, is permitted by the copyright holders
   * if the distribution is compliant with both the GNU General Public
   * License version 2 and the aforementioned licenses.
   *
   * This program is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
   * Public License for more details.
   */
  package org.n52.wps.test;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.containsString;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.not;
  import static org.hamcrest.Matchers.nullValue;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.net.URL;
  
  import javax.xml.parsers.ParserConfigurationException;
  
  import org.apache.commons.codec.binary.Base64;
  import org.apache.xmlbeans.XmlException;
  import org.apache.xmlbeans.XmlObject;
  import org.junit.BeforeClass;
  import org.junit.Test;
  import org.n52.wps.io.data.GenericFileDataConstants;
  import org.n52.wps.io.data.binding.complex.GTRasterDataBinding;
  import org.n52.wps.io.data.binding.complex.GTVectorDataBinding;
  import org.n52.wps.io.datahandler.parser.GTBinZippedSHPParser;
  import org.n52.wps.io.datahandler.parser.GeotiffParser;
  import org.xml.sax.SAXException;
  
  import com.vividsolutions.jts.io.InputStreamInStream;
  
  /**
   * 
   * To run this integration tests the GRASS 7 repository must be enabled and properly configured in the WPS config.
   *  
   */
  public class GrassIT {
  
      private static String wpsUrl;
  
      private String hostExp = "$host$";
      private String portExp = "$port$";
      
      @BeforeClass
      public static void beforeClass() {
          wpsUrl = AllTestsIT.getURL();
      }
  
      @Test
      public void decribeProcess() throws IOException, ParserConfigurationException, SAXException {
          String identifier = "v.buffer";
          String response = GetClient.sendRequest(wpsUrl, "Service=WPS&Request=DescribeProcess&Version=1.0.0&Identifier="
                  + identifier);
  
          assertThat(AllTestsIT.parseXML(response), is(not(nullValue())));
          assertThat(response, not(containsString("ExceptionReport")));
          assertThat(response, containsString(identifier));
      }
  
      @Test
      public void capabilitiesContainProcess() throws IOException, ParserConfigurationException, SAXException {
          String response = GetClient.sendRequest(wpsUrl, "Service=WPS&Request=GetCapabilities");
  
          assertThat(AllTestsIT.parseXML(response), is(not(nullValue())));
          assertThat(response, not(containsString("ExceptionReport")));
          assertThat(response, containsString("v.buffer"));
      }
      
      @Test
      public void resultRawSHPIsBase64Encoded() throws IOException, ParserConfigurationException, SAXException, XmlException {
          
          URL resource = GrassIT.class.getResource("/Grass/v.buffer_request_out_shp_raw_base64.xml");
          XmlObject xmlPayload = XmlObject.Factory.parse(resource);
  
          String payload = xmlPayload.toString();
          String response = PostClient.sendRequest(wpsUrl, payload);
          assertThat(response, not(containsString("ExceptionReport")));
  
          assertTrue(Base64.isBase64(response));
      }
      
      @Test
      public void resultRawSHPIsNotBase64Encoded() throws XmlException, IOException {
          
          URL resource = GrassIT.class.getResource("/Grass/v.buffer_request_out_shp_raw.xml");
          XmlObject xmlPayload = XmlObject.Factory.parse(resource);
  
          String payload = xmlPayload.toString();
          InputStream response = PostClient.sendRequestForInputStream(wpsUrl, payload);
          
          GTBinZippedSHPParser gtBinZippedSHPParser = new GTBinZippedSHPParser();
          
          GTVectorDataBinding gtVectorDataBinding = gtBinZippedSHPParser.parse(response, GenericFileDataConstants.MIME_TYPE_ZIPPED_SHP, null);
          
          assertTrue(gtVectorDataBinding.getPayload() != null);
          assertTrue(gtVectorDataBinding.getPayload().size() != 0);
      }
      
      @Test
      public void resultEmbeddedSHPIsBase64Encoded() throws IOException, ParserConfigurationException, SAXException, XmlException {
      	
      	URL resource = GrassIT.class.getResource("/Grass/v.buffer_request_out_shp_doc_base64.xml");
      	XmlObject xmlPayload = XmlObject.Factory.parse(resource);
      	
      	String payload = xmlPayload.toString();
      	String response = PostClient.sendRequest(wpsUrl, payload);
      	assertThat(response, not(containsString("ExceptionReport")));
      	
      	AllTestsIT.checkInlineResultBase64(response);
      }
  	
  	@Test
  	public void resultRawGeoTiffIsBase64Encoded() throws IOException,
  	ParserConfigurationException, SAXException, XmlException {
  		
  		XmlObject xmlPayload = createPayloadReplacingHostAndPort("/Grass/r.resample_request_out_tiff_raw_base64.xml");
  		
  		String payload = xmlPayload.toString();
  		String response = PostClient.sendRequest(wpsUrl, payload);
  		assertThat(response, not(containsString("ExceptionReport")));
  		
  		assertTrue(Base64.isBase64(response));
  	}
      
      @Test
      public void resultRawGeoTiffIsNotBase64Encoded() throws XmlException, IOException {
  
      	XmlObject xmlPayload = createPayloadReplacingHostAndPort("/Grass/r.resample_request_out_tiff_raw.xml");
      	
      	String payload = xmlPayload.toString();
      	InputStream response = PostClient.sendRequestForInputStream(wpsUrl, payload);
      	
      	GeotiffParser geotiffParser = new GeotiffParser();
  
      	GTRasterDataBinding gtRasterDataBinding = geotiffParser.parse(response, "image/tiff", null);
      	
      	assertTrue(gtRasterDataBinding.getPayload() != null);
      	assertTrue(gtRasterDataBinding.getPayload().getEnvelope() != null);
      	assertTrue(gtRasterDataBinding.getPayload().getEnvelope().getLowerCorner().getCoordinate()[0] == 633872.54238781);
      }
  
  	@Test
  	public void resultEmbeddedGeoTiffIsBase64Encoded() throws IOException,
  			ParserConfigurationException, SAXException, XmlException {
  
  		XmlObject xmlPayload = createPayloadReplacingHostAndPort("/Grass/r.resample_request_out_tiff_doc_base64.xml");
  
  		String payload = xmlPayload.toString();
  		String response = PostClient.sendRequest(wpsUrl, payload);
  		assertThat(response, not(containsString("ExceptionReport")));
  
  		AllTestsIT.checkInlineResultBase64(response);
  	}
  	
  	private XmlObject createPayloadReplacingHostAndPort(String resourceURL){
  		
  		URL resource = GrassIT.class
  				.getResource(resourceURL);
  		
  		try {
  			BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(resource.openStream()));
  			
  			String payload = "";
  			
  			String line = "";
  			
  			while((line = bufferedReader.readLine()) != null){
  				
  				if(line.contains(hostExp)){
  					line = line.replace(hostExp, AllTestsIT.getHost());
  				}
  				if(line.contains(portExp)){
  					line = line.replace(portExp, ""+AllTestsIT.getPort());
  				}
  				payload = payload.concat(line);
  			}
  			bufferedReader.close();
  			return XmlObject.Factory.parse(payload);
  		} catch (IOException e) {
  			fail(e.getMessage());
  		} catch (XmlException e) {
  			fail(e.getMessage());
  		}
  		return XmlObject.Factory.newInstance();
  		
  	}
  }
  