* Copyright 2011 JBoss Inc

*

* Licensed 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.

*/

   

    private Abdera abdera = new Abdera();

    public BasicPackageResourceIntegrationTest() {

        autoLoginAsAdmin = false;

    }

    // Unreliable HACK

    // Fixable after this is testing: https://issues.jboss.org/browse/ARQ-540

    @Test

    public void startServers() throws Exception {

        loginAs("admin");

        //Package version 1(Initial version)

        ModuleItem pkg = rulesRepository.createModule( "restPackage1",

                                                                   "this is package restPackage1" );

        //Package version 2 

        DroolsHeader.updateDroolsHeader( "import org.drools.Cheese\n global org.drools.Person customer1",

                                         pkg );

        AssetItem func = pkg.addAsset( "func",

                                       "" );

        func.updateFormat( AssetFormats.FUNCTION );

        func.updateContent( "function void foo() { System.out.println(\"version 1\"); }" );

        func.checkin( "version 1" );

        AssetItem dsl = pkg.addAsset( "myDSL",

                                      "" );

        dsl.updateFormat( AssetFormats.DSL );

        dsl.updateContent( "[then]call a func=foo();\n[when]foo=FooBarBaz1()" );

        dsl.checkin( "version 1" );

        AssetItem rule = pkg.addAsset( "rule1",

                                       "" );

        rule.updateFormat( AssetFormats.DRL );

        rule.updateContent( "rule 'foo' when Goo1() then end" );

        rule.checkin( "version 1" );

        AssetItem rule2 = pkg.addAsset( "rule2",

                                        "" );

        rule2.updateFormat( AssetFormats.DSL_TEMPLATE_RULE );

        rule2.updateContent( "when \n foo \n then \n call a func" );

        rule2.checkin( "version 1" );

        AssetItem rule3 = pkg.addAsset( "model1",

                                        "" );

        rule3.updateFormat( AssetFormats.DRL_MODEL );

        rule3.updateContent( "declare Album1\n genre1: String \n end" );

        rule3.checkin( "version 1" );

        AssetItem rule4 = pkg.addAsset( "rule4",

                                        "" );

        rule4.updateFormat( AssetFormats.DRL );

        rule4.updateContent( "rule 'nheron' when Cheese() then end" );

        rule4.checkin( "version 1" );

        pkg.checkin( "version2" );

        //Package version 3

        DroolsHeader.updateDroolsHeader( "import org.drools.Cheese\n global org.drools.Person customer2",

                                         pkg );

        func.updateContent( "function void foo() { System.out.println(\"version 2\"); }" );

        func.checkin( "version 2" );

        dsl.updateContent( "[then]call a func=foo();\n[when]foo=Cheese()" );

        dsl.checkin( "version 2" );

        rule.updateContent( "rule 'foo' when Cheese() then end" );

        rule.checkin( "version 2" );

        rule2.updateContent( "when \n foo \n then \n call a func" );

        rule2.checkin( "version 2" );

        rule3.updateContent( "declare Album2\n genre2: String \n end" );

        rule3.checkin( "version 2" );

        //impl.buildPackage(pkg.getUUID(), true);

        pkg.checkin( "version3" );

       

        ModuleItem pkg2 = rulesRepository.createModule( "restPackage2",

                "this is package restPackage2" );  

        pkg2.checkout();

        repositoryPackageService.buildPackage(pkg2.getUUID(), true);       

        pkg2.checkin("version2");

        pkg2.checkout();

        repositoryPackageService.buildPackage(pkg2.getUUID(), true);      

        pkg2.checkin("version3");

        ModuleItem pkg3 = rulesRepository.createModule( "restPackageCompilationFailure",

                "this is package restPackageCompilationFailure" );

        DroolsHeader.updateDroolsHeader( "import org.drools.NonExistingClass",

                pkg3 );

        AssetItem brokenRule = pkg3.addAsset( "ruleCompilationFailure",

                "" );

        brokenRule.updateFormat(AssetFormats.DRL);

        brokenRule.updateContent("rule 'compilationFailure' when NonExistingClass() then end");

        brokenRule.checkin("version 1");

        pkg3.checkin("version2");

       

        logoutAs("admin");

    }

   

    @Test @RunAsClient

    public void testBasicAuthenticationInvalidPassword(@ArquillianResource URL baseURL) throws MalformedURLException, IOException {

        //Test with invalid user name and pwd

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        byte[] authEncBytes = Base64.encodeBase64("admin:invalidPassword"

                .getBytes());

        connection.setRequestProperty("Authorization", "Basic "

                + new String(authEncBytes));

        connection.connect();

        assertEquals (401, connection.getResponseCode());

        //assertEquals(MediaType.APPLICATION_ATOM_XML, connection.getContentType());

    }

    @Test @RunAsClient

    public void testBasicAuthentication(@ArquillianResource URL baseURL) throws MalformedURLException, IOException {

        //Test with valid user name and pwd

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        byte[] authEncBytes = Base64.encodeBase64("admin:admin".getBytes());

        connection.setRequestProperty("Authorization", "Basic "

                + new String(authEncBytes));

        connection.connect();

        assertEquals (200, connection.getResponseCode());

        assertEquals(MediaType.APPLICATION_ATOM_XML, connection.getContentType());

        //System.out.println(IOUtils.toString(connection.getInputStream()));

    }

    /**

     * Test of getPackagesAsFeed method, of class PackageService.

     */

    @Test @RunAsClient

    public void testGetPackagesForJSON(@ArquillianResource URL baseURL) throws MalformedURLException, IOException {

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_JSON);

        connection.connect();

        assertEquals (200, connection.getResponseCode());       

        assertEquals(MediaType.APPLICATION_JSON, connection.getContentType());

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        //TODO: verify

     }

    /**

     * Test of getPackagesAsFeed method, of class PackageService.

     */

    @Test @RunAsClient

    public void testGetPackagesForXML(@ArquillianResource URL baseURL) throws MalformedURLException, IOException {

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_XML);

        connection.connect();

        assertEquals (200, connection.getResponseCode());

        assertEquals(MediaType.APPLICATION_XML, connection.getContentType());

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        //TODO: verify

    }

    /**

     * Test of getPackagesAsFeed method, of class PackageService.

     */

    @Test @RunAsClient

    public void testGetPackagesForAtom(@ArquillianResource URL baseURL) throws MalformedURLException, IOException {

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        connection.connect();

        assertEquals (200, connection.getResponseCode());

        assertEquals(MediaType.APPLICATION_ATOM_XML, connection.getContentType());

        //System.out.println(IOUtils.toString(connection.getInputStream()));

       

        InputStream in = connection.getInputStream();

        assertNotNull(in);

    Document<Feed> doc = abdera.getParser().parse(in);

    Feed feed = doc.getRoot();

    assertEquals(baseURL.getPath() + "rest/packages", feed.getBaseUri().getPath());

    assertEquals("Packages", feed.getTitle());

   

    List<Entry> entries = feed.getEntries();

    assertEquals(4, entries.size());

    Iterator<Entry> it = entries.iterator(); 

    boolean foundPackageEntry = false;

    while (it.hasNext()) {

      Entry entry = it.next();

      if("restPackage1".equals(entry.getTitle())) {

        foundPackageEntry = true;

        List<Link> links = entry.getLinks();

        assertEquals(1, links.size());

        assertEquals(baseURL.getPath() + "rest/packages/restPackage1", links.get(0).getHref().getPath());

      }

    }

    assertTrue(foundPackageEntry);

    }

    /**

     * Test of getPackagesAsFeed method, of class PackageService.

     */

    @Test @RunAsClient

    public void testGetPackageForJSON(@ArquillianResource URL baseURL) throws MalformedURLException, IOException {

        URL url = new URL(baseURL, "rest/packages/restPackage1");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_JSON);

        connection.connect();

        assertEquals (200, connection.getResponseCode());

        assertEquals(MediaType.APPLICATION_JSON, connection.getContentType());

        //logger.log (LogLevel, IOUtils.toString(connection.getInputStream()));

    }

    /**

     * Test of getPackagesAsFeed method, of class PackageService.

     * An example of expected result:

     *

     *   <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>

     *   <package>

     *     <binaryLink>http://127.0.0.1:8080/da8f3038-194b-4627-ae55-94b1f21d8e24/rest/packages/restPackage1/binary</binaryLink>

     *     <description>this is package restPackage1</description>

     *     <sourceLink>http://127.0.0.1:8080/da8f3038-194b-4627-ae55-94b1f21d8e24/rest/packages/restPackage1/source</sourceLink>

     *     <title>restPackage1</title>

     *     <author>guest</author>

     *     <published>2012-01-31T19:15:56.933+08:00</published>

     *     <metadata>

     *       <archived>false</archived>

     *       <created>2012-01-30T16:48:37.081+08:00</created>

     *       <state />

     *       <uuid>690e386a-89df-4018-8688-cb322b492f53</uuid>

     *       <versionNumber>3</versionNumber>

     *       <checkInComment>version3</checkInComment>

     *     </metadata>

     *    

     *     <assets>http://127.0.0.1:8080/da8f3038-194b-4627-ae55-94b1f21d8e24/rest/packages/restPackage1/assets/rule4</assets>

     *     <assets>http://127.0.0.1:8080/da8f3038-194b-4627-ae55-94b1f21d8e24/rest/packages/restPackage1/assets/drools</assets>

     *     <assets>http://127.0.0.1:8080/da8f3038-194b-4627-ae55-94b1f21d8e24/rest/packages/restPackage1/assets/rule1</assets>

     *     <assets>http://127.0.0.1:8080/da8f3038-194b-4627-ae55-94b1f21d8e24/rest/packages/restPackage1/assets/func</assets>

     *     <assets>http://127.0.0.1:8080/da8f3038-194b-4627-ae55-94b1f21d8e24/rest/packages/restPackage1/assets/myDSL</assets>

     *     <assets>http://127.0.0.1:8080/da8f3038-194b-4627-ae55-94b1f21d8e24/rest/packages/restPackage1/assets/rule2</assets>

     *     <assets>http://127.0.0.1:8080/da8f3038-194b-4627-ae55-94b1f21d8e24/rest/packages/restPackage1/assets/model1</assets>

     *   </package>    

     */

    @Test @RunAsClient

    public void testGetPackageForXML(@ArquillianResource URL baseURL) throws Exception {

        URL url = new URL(baseURL, "rest/packages/restPackage1");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_XML);

        connection.connect();

        assertEquals (200, connection.getResponseCode());

        assertEquals(MediaType.APPLICATION_XML, connection.getContentType());

        //System.out.println("------------------------");

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        Package p = unmarshalPackageXML(connection.getInputStream());

        assertEquals("restPackage1", p.getTitle());

        assertEquals("this is package restPackage1", p.getDescription());

        assertNotNull(p.getAuthor());      

        assertNotNull(p.getPublished());

        assertEquals(new URL(baseURL, "rest/packages/restPackage1/source").toExternalForm(), p.getSourceLink().toString());

        assertEquals(new URL(baseURL, "rest/packages/restPackage1/binary").toExternalForm(), p.getBinaryLink().toString());

        PackageMetadata pm = p.getMetadata();

        assertFalse(pm.isArchived());

        assertNotNull(pm.getCreated());

        assertNotNull(pm.getUuid());

        assertEquals("version3", pm.getCheckinComment());

        assertEquals(3, pm.getVersionNumber());

       

        Set<URI> assetsURI = p.getAssets();       

        assertEquals(7, assetsURI.size());

      assertTrue(assetsURI.contains(new URL(baseURL, "rest/packages/restPackage1/assets/drools").toURI()));

      assertTrue(assetsURI.contains(new URL(baseURL, "rest/packages/restPackage1/assets/func").toURI()));

      assertTrue(assetsURI.contains(new URL(baseURL, "rest/packages/restPackage1/assets/myDSL").toURI()));

      assertTrue(assetsURI.contains(new URL(baseURL, "rest/packages/restPackage1/assets/rule1").toURI()));

      assertTrue(assetsURI.contains(new URL(baseURL, "rest/packages/restPackage1/assets/rule2").toURI()));

      assertTrue(assetsURI.contains(new URL(baseURL, "rest/packages/restPackage1/assets/rule4").toURI()));

      assertTrue(assetsURI.contains(new URL(baseURL, "rest/packages/restPackage1/assets/model1").toURI()));

    }

    /**

     * Test of getPackageAsEntry method, of class PackageResource.

     *

     * An example of expected result:

     *

     * <entry xmlns="http://www.w3.org/2005/Atom" xml:base="http://127.0.0.1:8080/1c71582d-3f64-4027-bc5a-d442ab4816e6/rest/packages/restPackage1">

     *   <title type="text">restPackage1</title>

     *   <summary type="text">this is package restPackage1</summary>

     *   <published>2012-01-30T08:17:29.321Z</published>

     *   <author>

     *     <name>guest</name>

     *   </author>  

     *   <id>http://127.0.0.1:8080/1c71582d-3f64-4027-bc5a-d442ab4816e6/rest/packages/restPackage1</id>

     *  

     *   <link href= "http://127.0.0.1:8080/1c71582d-3f64-4027-bc5a-d442ab4816e6/rest/packages/restPackage1/assets/drools" title="drools" rel="asset" />

     *   <link href= "http://127.0.0.1:8080/1c71582d-3f64-4027-bc5a-d442ab4816e6/rest/packages/ restPackage1/assets/func" title="func" rel="asset" />

     *   <link href= "http://127.0.0.1:8080/1c71582d-3f64-4027-bc5a-d442ab4816e6/rest/packages/restPackage1/assets/myDSL" title="myDSL" rel="asset" />

     *   <link href= "http://127.0.0.1:8080/1c71582d-3f64-4027-bc5a-d442ab4816e6/rest/packages/restPackage1/assets/rule1" title="rule1" rel="asset" />

     *   <link href= "http://127.0.0.1:8080/1c71582d-3f64-4027-bc5a-d442ab4816e6/rest/packages/restPackage1/assets/rule2" title="rule2" rel="asset" />

     *   <link href= "http://127.0.0.1:8080/1c71582d-3f64-4027-bc5a-d442ab4816e6/rest/packages/restPackage1/assets/model1" title="model1" rel="asset" />

     *   <link href= "http://127.0.0.1:8 080/1c71582d-3f64-4027-bc5a-d442ab4816e6/rest/packages/restPackage1/assets/rule4" title="rule4" rel="asset" />

     *  

     *   <metadata xmlns="">

     *     <archived>

     *       <value>false</value>

     *     </archived>

     *     <uuid>

     *       <value>a2cabf64-bf84-4a42-83f0-1ce24702fc63</value>

     *     </uuid>

     *     <state>

     *       <value />

     *     </state>

     *     <versionNumber>

     *       <value>3</value>

     *     </versionNumber>

     *     <checkinComment>

     *       <value>version3</value>

     *     </checkinComment>

     *   </metadata>

     *  

     *   <content src= "http://127.0.0.1:8080/1c71582d-3 f64-4027-bc5a-d442ab4816e6/rest/packages/restPackage1/binary"/>

     * </entry>

     */

    @Test @RunAsClient

    public void testGetPackageForAtom(@ArquillianResource URL baseURL) throws MalformedURLException, IOException {

        URL url = new URL(baseURL, "rest/packages/restPackage1");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        connection.connect();

        assertEquals (200, connection.getResponseCode());

        assertEquals(MediaType.APPLICATION_ATOM_XML, connection.getContentType());

        //System.out.println("------------------------");

        //System.out.println(IOUtils.toString(connection.getInputStream()));

       

        InputStream in = connection.getInputStream();

        assertNotNull(in);

    Document<Entry> doc = abdera.getParser().parse(in);

    Entry entry = doc.getRoot();

    assertEquals(baseURL.getPath() + "rest/packages/restPackage1", entry.getBaseUri().getPath());

    assertEquals("restPackage1", entry.getTitle());

    assertNotNull(entry.getPublished());

    assertNotNull(entry.getAuthor().getName());   

    assertEquals("this is package restPackage1", entry.getSummary());

    //assertEquals(MediaType.APPLICATION_OCTET_STREAM_TYPE.getType(), entry.getContentMimeType().getPrimaryType());

    assertEquals(baseURL.getPath() + "rest/packages/restPackage1/binary", entry.getContentSrc().getPath());

   

    List<Link> links = entry.getLinks();

    assertEquals(7, links.size());

    Map<String, Link> linksMap = new HashMap<String, Link>();

    for(Link link : links){

      linksMap.put(link.getTitle(), link);

    }

   

    assertEquals(baseURL.getPath() + "rest/packages/restPackage1/assets/drools", linksMap.get("drools").getHref().getPath());

    assertEquals(baseURL.getPath() + "rest/packages/restPackage1/assets/func", linksMap.get("func").getHref().getPath());

    assertEquals(baseURL.getPath() + "rest/packages/restPackage1/assets/myDSL", linksMap.get("myDSL").getHref().getPath());

    assertEquals(baseURL.getPath() + "rest/packages/restPackage1/assets/rule1", linksMap.get("rule1").getHref().getPath());

    assertEquals(baseURL.getPath() + "rest/packages/restPackage1/assets/rule2", linksMap.get("rule2").getHref().getPath());

    assertEquals(baseURL.getPath() + "rest/packages/restPackage1/assets/rule4", linksMap.get("rule4").getHref().getPath());

    assertEquals(baseURL.getPath() + "rest/packages/restPackage1/assets/model1", linksMap.get("model1").getHref().getPath());

   

    ExtensibleElement metadataExtension  = entry.getExtension(Translator.METADATA);

        ExtensibleElement archivedExtension = metadataExtension.getExtension(Translator.ARCHIVED);    

    assertEquals("false", archivedExtension.getSimpleExtension(Translator.VALUE));

        ExtensibleElement uuidExtension = metadataExtension.getExtension(Translator.UUID);    

    assertNotNull(uuidExtension.getSimpleExtension(Translator.VALUE));

        ExtensibleElement checkinCommentExtension = metadataExtension.getExtension(Translator.CHECKIN_COMMENT); 

        assertEquals("version3", checkinCommentExtension.getSimpleExtension(Translator.VALUE));

        ExtensibleElement versionNumberExtension = metadataExtension.getExtension(Translator.VERSION_NUMBER); 

        assertEquals("3", versionNumberExtension.getSimpleExtension(Translator.VALUE));

    }

    /* Package Creation */

    @Test @RunAsClient

    public void testCreatePackageFromJAXB(@ArquillianResource URL baseURL) throws Exception {

        Package p = createTestPackage("TestCreatePackageFromJAXB");

        p.setDescription("desc for testCreatePackageFromJAXB");

        JAXBContext context = JAXBContext.newInstance(p.getClass());

        Marshaller marshaller = context.createMarshaller();

        StringWriter sw = new StringWriter();

        marshaller.marshal(p, sw);

        String xml = sw.toString();

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("POST");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_XML);

        connection.setRequestProperty("Content-Type", MediaType.APPLICATION_XML);

        connection.setRequestProperty("Content-Length", Integer.toString(xml.getBytes().length));

        connection.setUseCaches (false);

        connection.setDoInput(true);

        connection.setDoOutput(true);

        //Send request

        DataOutputStream wr = new DataOutputStream (

              connection.getOutputStream ());

        wr.writeBytes (xml);

        wr.flush ();

        wr.close ();

        assertEquals (200, connection.getResponseCode());

        assertEquals(MediaType.APPLICATION_XML, connection.getContentType());

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        Package result = unmarshalPackageXML(connection.getInputStream());

        assertEquals("TestCreatePackageFromJAXB", result.getTitle());

        assertEquals("desc for testCreatePackageFromJAXB", result.getDescription());

        assertNotNull(result.getPublished());

        assertEquals(new URL(baseURL, "rest/packages/TestCreatePackageFromJAXB/source").toExternalForm(), result.getSourceLink().toString());

        assertEquals(new URL(baseURL, "rest/packages/TestCreatePackageFromJAXB/binary").toExternalForm(), result.getBinaryLink().toString());

        PackageMetadata pm = result.getMetadata();

        assertFalse(pm.isArchived());

        assertNotNull(pm.getCreated());

        assertNotNull(pm.getUuid());

    }

    /* Package Creation */

    @Test @RunAsClient

    public void testCreatePackageFromDRLAsEntry(@ArquillianResource URL baseURL) throws Exception {

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("POST");

        connection.setRequestProperty("Content-Type", MediaType.APPLICATION_OCTET_STREAM);

        connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        connection.setDoOutput(true);

        //Send request

        InputStream in = null;

        OutputStream out = null;

        try {

            in = getClass().getResourceAsStream("simple_rules.drl");

            out = connection.getOutputStream();

            IOUtils.copy(in, out);

        } finally {

            IOUtils.closeQuietly(in);

            IOUtils.closeQuietly(out);

        }

        assertEquals (200, connection.getResponseCode());

        assertEquals (MediaType.APPLICATION_ATOM_XML, connection.getContentType());

        //logger.log(LogLevel, IOUtils.toString(connection.getInputStream()));

    }

    @Test @RunAsClient

    public void testCreatePackageFromDRLAsJson(@ArquillianResource URL baseURL) throws Exception {

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("POST");

        connection.setRequestProperty("Content-Type", MediaType.APPLICATION_OCTET_STREAM);

        connection.setRequestProperty("Accept", MediaType.APPLICATION_JSON);

        connection.setDoOutput(true);

        //Send request

        InputStream in = null;

        OutputStream out = null;

        try {

            in = getClass().getResourceAsStream("simple_rules2.drl");

            out = connection.getOutputStream();

            IOUtils.copy(in, out);

        } finally {

            IOUtils.closeQuietly(in);

            IOUtils.closeQuietly(out);

        }

        assertEquals (200, connection.getResponseCode());

        assertEquals (MediaType.APPLICATION_JSON, connection.getContentType());

        //logger.log(LogLevel, IOUtils.toString(connection.getInputStream()));

    }

    @Test @RunAsClient

    public void testCreatePackageFromDRLAsJaxB(@ArquillianResource URL baseURL) throws Exception {

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("POST");

        connection.setRequestProperty("Content-Type", MediaType.APPLICATION_OCTET_STREAM);

        connection.setRequestProperty("Accept", MediaType.APPLICATION_XML);

        connection.setDoOutput(true);

        //Send request

        InputStream in = null;

        OutputStream out = null;

        try {

            in = getClass().getResourceAsStream("simple_rules3.drl");

            out = connection.getOutputStream();

            IOUtils.copy(in, out);

        } finally {

            IOUtils.closeQuietly(in);

            IOUtils.closeQuietly(out);

        }

        assertEquals(200, connection.getResponseCode());

        assertEquals (MediaType.APPLICATION_XML, connection.getContentType());

        //logger.log(LogLevel, IOUtils.toString(connection.getInputStream()));

    }

    @Test @RunAsClient

    public void testCreateAndUpdateAndDeletePackageFromAtom(@ArquillianResource URL baseURL) throws Exception {

      //Test create

      Abdera abdera = new Abdera();

      AbderaClient client = new AbderaClient(abdera);

        client.addCredentials(baseURL.toExternalForm(), null, null,

                new org.apache.commons.httpclient.UsernamePasswordCredentials("admin", "admin"));

      Entry entry = abdera.newEntry();   

      entry.setTitle("testCreatePackageFromAtom");

      entry.setSummary("desc for testCreatePackageFromAtom");

        ExtensibleElement extension = entry.addExtension(Translator.METADATA);

        ExtensibleElement childExtension = extension.addExtension(Translator.CHECKIN_COMMENT);

        childExtension.addSimpleExtension(Translator.VALUE, "checkin comment:initial desc for testCreatePackageFromAtom"); 

     

      ClientResponse resp = client.post(new URL(baseURL, "rest/packages").toExternalForm(), entry);

        //System.out.println(GetContent(resp.getInputStream()));

    assertEquals(ResponseType.SUCCESS, resp.getType());

    Document<Entry> doc = resp.getDocument();

    Entry returnedEntry = doc.getRoot();

    assertEquals(baseURL.getPath() + "rest/packages/testCreatePackageFromAtom", returnedEntry.getBaseUri().getPath());

    assertEquals("testCreatePackageFromAtom", returnedEntry.getTitle());

    assertEquals("desc for testCreatePackageFromAtom", returnedEntry.getSummary());

        ExtensibleElement metadataExtension  = entry.getExtension(Translator.METADATA);

        ExtensibleElement checkinCommentExtension = metadataExtension.getExtension(Translator.CHECKIN_COMMENT); 

        assertEquals("checkin comment:initial desc for testCreatePackageFromAtom", checkinCommentExtension.getSimpleExtension(Translator.VALUE));

       

       

    //Test update package

        Entry e = abdera.newEntry();

        e.setTitle("testCreatePackageFromAtom");

        org.apache.abdera.model.Link l = Abdera.getNewFactory().newLink();

        l.setHref(new URL(baseURL, "rest/packages/testCreatePackageFromAtom").toExternalForm());

        l.setRel("self");

        e.addLink(l);

        e.setSummary("updated desc for testCreatePackageFromAtom");

        e.addAuthor("Test McTesty");   

        extension = e.addExtension(Translator.METADATA);

        childExtension = extension.addExtension(Translator.CHECKIN_COMMENT);

        childExtension.addSimpleExtension(Translator.VALUE, "checkin comment:updated desc for testCreatePackageFromAtom"); 

        resp = client.put(new URL(baseURL, "rest/packages/testCreatePackageFromAtom").toExternalForm(), e);

        assertEquals(ResponseType.SUCCESS, resp.getType());

        assertEquals(204, resp.getStatus());

        //NOTE: could not figure out why the code below always returns -1 as the ResponseCode.

        HttpURLConnection conn = (HttpURLConnection) url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        conn.setRequestMethod("PUT");

        conn.setRequestProperty("Content-type", MediaType.APPLICATION_ATOM_XML);

        conn.setRequestProperty("Content-Length", Integer.toString(e.toString().getBytes().length));

        conn.setDoOutput(true);

        e.writeTo(conn.getOutputStream());

        assertEquals(204, conn.getResponseCode());

        conn.disconnect(); */

        URL url1 = new URL(baseURL, "rest/packages/testCreatePackageFromAtom");

        HttpURLConnection conn1 = (HttpURLConnection)url1.openConnection();

        conn1.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        conn1.setRequestMethod("GET");

        conn1.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        conn1.connect();

        //System.out.println(GetContent(conn));

        assertEquals (200, conn1.getResponseCode());

        assertEquals(MediaType.APPLICATION_ATOM_XML, conn1.getContentType());

       

        InputStream in = conn1.getInputStream();

        assertNotNull(in);

    doc = abdera.getParser().parse(in);

    entry = doc.getRoot();

    assertEquals(baseURL.getPath() + "rest/packages/testCreatePackageFromAtom", entry.getBaseUri().getPath());

    assertEquals("testCreatePackageFromAtom", entry.getTitle());

    assertNotNull(entry.getPublished());

      assertNotNull(entry.getAuthor().getName());    

    assertEquals("updated desc for testCreatePackageFromAtom", entry.getSummary());

        metadataExtension  = entry.getExtension(Translator.METADATA);

        checkinCommentExtension = metadataExtension.getExtension(Translator.CHECKIN_COMMENT); 

        assertEquals("checkin comment:updated desc for testCreatePackageFromAtom", checkinCommentExtension.getSimpleExtension(Translator.VALUE));

       

    //Roll back changes.

    resp = client.delete(new URL(baseURL, "rest/packages/testCreatePackageFromAtom").toExternalForm());

    assertEquals(ResponseType.SUCCESS, resp.getType());

    //Verify the package is indeed deleted

    URL url2 = new URL(baseURL, "rest/packages/testCreatePackageFromAtom");

    HttpURLConnection conn2 = (HttpURLConnection)url2.openConnection();

        conn2.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        conn2.setRequestMethod("GET");

        conn2.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        conn2.connect();

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        assertEquals (404, conn2.getResponseCode());

    }

   

    @Test @RunAsClient

    public void testRenamePackageFromAtom(@ArquillianResource URL baseURL) throws Exception {

        //create a package for testing

        Abdera abdera = new Abdera();

        AbderaClient client = new AbderaClient(abdera);

        client.addCredentials(baseURL.toExternalForm(), null, null,

                new org.apache.commons.httpclient.UsernamePasswordCredentials("admin", "admin"));

        Entry entry = abdera.newEntry();       

        entry.setTitle("testRenamePackageFromAtom");

        entry.setSummary("desc for testRenamePackageFromAtom");

       

        ClientResponse resp = client.post(new URL(baseURL, "rest/packages").toExternalForm(), entry);

        //System.out.println(GetContent(resp.getInputStream()));

        assertEquals(ResponseType.SUCCESS, resp.getType());

        Document<Entry> doc = resp.getDocument();

        Entry returnedEntry = doc.getRoot();

        assertEquals(baseURL.getPath() + "rest/packages/testRenamePackageFromAtom", returnedEntry.getBaseUri().getPath());

        assertEquals("testRenamePackageFromAtom", returnedEntry.getTitle());

        assertEquals("desc for testRenamePackageFromAtom", returnedEntry.getSummary());

       

       

        //Test rename package

        Entry e = abdera.newEntry();

        e.setTitle("testRenamePackageFromAtomNew");

        org.apache.abdera.model.Link l = Abdera.getNewFactory().newLink();

        l.setHref(new URL(baseURL, "rest/packages/testRenamePackageFromAtomNew").toExternalForm());

        l.setRel("self");

        e.addLink(l);

        e.setSummary("renamed package testRenamePackageFromAtom");

        e.addAuthor("Test McTesty");       

        resp = client.put(new URL(baseURL, "rest/packages/testRenamePackageFromAtom").toExternalForm(), e);

        assertEquals(ResponseType.SUCCESS, resp.getType());

        assertEquals(204, resp.getStatus());

       

        //Verify new package is available after renaming

        URL url1 = new URL(baseURL, "rest/packages/testRenamePackageFromAtomNew");

        HttpURLConnection conn1 = (HttpURLConnection)url1.openConnection();

        conn1.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        conn1.setRequestMethod("GET");

        conn1.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        conn1.connect();

        //System.out.println(GetContent(conn));

        assertEquals (200, conn1.getResponseCode());

        assertEquals(MediaType.APPLICATION_ATOM_XML, conn1.getContentType());

       

        InputStream in = conn1.getInputStream();

        assertNotNull(in);

        doc = abdera.getParser().parse(in);

        entry = doc.getRoot();

        assertEquals(baseURL.getPath() + "rest/packages/testRenamePackageFromAtomNew", entry.getBaseUri().getPath());

        assertEquals("testRenamePackageFromAtomNew", entry.getTitle());

        assertTrue(entry.getPublished() != null);

        assertEquals("renamed package testRenamePackageFromAtom", entry.getSummary());

       

       

        //Verify the old package does not exist after renaming

        URL url2 = new URL(baseURL, "rest/packages/testRenamePackageFromAtom");

        HttpURLConnection conn2 = (HttpURLConnection)url2.openConnection();

        conn2.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        conn2.setRequestMethod("GET");

        conn2.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        conn2.connect();

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        assertEquals (404, conn2.getResponseCode());

       

       

        //Roll back changes.

        resp = client.delete(new URL(baseURL, "rest/packages/testRenamePackageFromAtomNew").toExternalForm());

        assertEquals(ResponseType.SUCCESS, resp.getType());

       

        //Verify the package is indeed deleted

        URL url3 = new URL(baseURL, "rest/packages/testRenamePackageFromAtomNew");

        HttpURLConnection conn3 = (HttpURLConnection)url3.openConnection();

        conn3.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        conn3.setRequestMethod("GET");

        conn3.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        conn3.connect();

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        assertEquals (404, conn3.getResponseCode());

    }

   

    @Test @RunAsClient

    public void testRenamePackageFromXML(@ArquillianResource URL baseURL) throws Exception {

        //create a package for testing

        Package p = createTestPackage("testRenamePackageFromXML");

        p.setDescription("desc for testRenamePackageFromXML");

        JAXBContext context = JAXBContext.newInstance(p.getClass());

        Marshaller marshaller = context.createMarshaller();

        StringWriter sw = new StringWriter();

        marshaller.marshal(p, sw);

        String xml = sw.toString();

        URL url = new URL(baseURL, "rest/packages");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("POST");

        connection.setRequestProperty("Content-Type", MediaType.APPLICATION_XML);

        connection.setRequestProperty("Content-Length", Integer.toString(xml.getBytes().length));

        connection.setUseCaches (false);

        connection.setDoInput(true);

        connection.setDoOutput(true);

        connection.setRequestProperty("Accept", MediaType.APPLICATION_XML);

       

        DataOutputStream wr = new DataOutputStream (connection.getOutputStream ());

        wr.writeBytes (xml);

        wr.flush ();

        wr.close ();

        assertEquals (200, connection.getResponseCode());

        assertEquals(MediaType.APPLICATION_XML, connection.getContentType());

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        Package result = unmarshalPackageXML(connection.getInputStream());

        assertEquals("testRenamePackageFromXML", result.getTitle());

        assertEquals("desc for testRenamePackageFromXML", result.getDescription());

        assertNotNull(result.getPublished());

        assertEquals(new URL(baseURL, "rest/packages/testRenamePackageFromXML/source").toExternalForm(), result.getSourceLink().toString());

        assertEquals(new URL(baseURL, "rest/packages/testRenamePackageFromXML/binary").toExternalForm(), result.getBinaryLink().toString());

        PackageMetadata pm = result.getMetadata();

        assertFalse(pm.isArchived());

        assertNotNull(pm.getCreated());

        assertNotNull(pm.getUuid());

        

       

        //Test rename package     

        p.setDescription("renamed package testRenamePackageFromXML");

        p.setTitle("testRenamePackageFromXMLNew");

        JAXBContext context2 = JAXBContext.newInstance(p.getClass());

        Marshaller marshaller2 = context2.createMarshaller();

        StringWriter sw2 = new StringWriter();

        marshaller2.marshal(p, sw2);

        String xml2 = sw2.toString();

        URL url2 = new URL(baseURL, "rest/packages/testRenamePackageFromXML");

        HttpURLConnection connection2 = (HttpURLConnection)url2.openConnection();

        connection2.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection2.setRequestMethod("PUT");

        connection2.setRequestProperty("Content-Type", MediaType.APPLICATION_XML);

        connection2.setRequestProperty("Content-Length", Integer.toString(xml2.getBytes().length));

        connection2.setUseCaches (false);

        //connection2.setDoInput(true);

        connection2.setDoOutput(true);

        OutputStreamWriter out = new OutputStreamWriter(connection2.getOutputStream());

        out.write(xml2);

        out.close();

        connection2.getInputStream();

        //assertEquals (200, connection2.getResponseCode());

       

        //Verify the new package is available after renaming

        URL url3 = new URL(baseURL, "rest/packages/testRenamePackageFromXMLNew");

        HttpURLConnection conn3 = (HttpURLConnection)url3.openConnection();

        conn3.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        conn3.setRequestMethod("GET");

        conn3.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        conn3.connect();

        //System.out.println(GetContent(conn));

        assertEquals (200, conn3.getResponseCode());

        assertEquals(MediaType.APPLICATION_ATOM_XML, conn3.getContentType());

       

        InputStream in = conn3.getInputStream();

        assertNotNull(in);

        Document<Entry> doc = abdera.getParser().parse(in);

        Entry entry = doc.getRoot();

        assertEquals(baseURL.getPath() + "rest/packages/testRenamePackageFromXMLNew", entry.getBaseUri().getPath());

        assertEquals("testRenamePackageFromXMLNew", entry.getTitle());

        assertTrue(entry.getPublished() != null);

        assertEquals("renamed package testRenamePackageFromXML", entry.getSummary());

       

       

        //Verify the old package does not exist after renaming

        URL url4 = new URL(baseURL, "rest/packages/testRenamePackageFromXML");

        HttpURLConnection conn4 = (HttpURLConnection)url4.openConnection();

        conn4.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        conn4.setRequestMethod("GET");

        conn4.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        conn4.connect();

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        assertEquals (404, conn4.getResponseCode());

       

       

        //Roll back changes.

        Abdera abdera = new Abdera();

        AbderaClient client = new AbderaClient(abdera);    

        client.addCredentials(baseURL.toExternalForm(), null, null,

                new org.apache.commons.httpclient.UsernamePasswordCredentials("admin", "admin"));

        ClientResponse resp = client.delete(new URL(baseURL, "rest/packages/testRenamePackageFromXMLNew").toExternalForm());

        assertEquals(ResponseType.SUCCESS, resp.getType());

       

        //Verify the package is indeed deleted

        URL url5 = new URL(baseURL, "rest/packages/testRenamePackageFromXMLNew");

        HttpURLConnection conn5 = (HttpURLConnection)url5.openConnection();

        conn5.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        conn5.setRequestMethod("GET");

        conn5.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        conn5.connect();

        //System.out.println(IOUtils.toString(connection.getInputStream()));

        assertEquals (404, conn5.getResponseCode());

    }

   

    @Ignore @Test @RunAsClient

    public void testCreatePackageFromJson(@ArquillianResource URL baseURL) {

        //TODO: implement test

    }

   

    @Test @RunAsClient

    public void testCreatePackageSnapshot(@ArquillianResource URL baseURL) throws Exception {

        URL url = new URL(baseURL, "rest/packages/restPackage1/snapshot/testsnapshot");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("POST");

        connection.setUseCaches (false);

        connection.setDoInput(true);

        connection.setDoOutput(true);

        assertEquals (204, connection.getResponseCode());

    }

    @Test @RunAsClient

    public void testPackageNotExists(@ArquillianResource URL baseURL) throws Exception {

        URL url = new URL(baseURL, "rest/packages/restNotExistingPackage");

        HttpURLConnection connection = (HttpURLConnection)url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);

        connection.connect();

        assertEquals(404, connection.getResponseCode());

    }

   

    @Test @RunAsClient

    public void testGetPackageSource(@ArquillianResource URL baseURL) throws Exception {

        URL url = new URL(baseURL, "rest/packages/restPackage1/source");

        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        connection.setRequestProperty("Authorization",

                "Basic " + new Base64().encodeToString(( "admin:admin".getBytes() )));

        connection.setRequestMethod("GET");

        connection.setRequestProperty("Accept", MediaType.WILDCARD);

        connection.connect();

        assertEquals (200, connection.getResponseCode());

        assertEquals(MediaType.TEXT_PLAIN, connection.getContentType());

        String result = IOUtils.toString(connection.getInputStream());

 

        assertEquals("attachment; filename=restPackage1", connection.getHeaderField("Content-Disposition"));

        assertTrue( result.indexOf( "package restPackage1" ) >= 0 );

        assertTrue( result.indexOf( "import org.drools.Cheese" ) >= 0 );

        assertTrue( result.indexOf( "global org.drools.Person customer2" ) >= 0 );