RepositoryBrowser_UT

/*
 * Copyright 2011 The Kuali Foundation.
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
 *
 * 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.
 */
package org.kuali.ole;

import org.apache.commons.io.FileUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.kuali.ole.docstore.model.enums.DocCategory;
import org.kuali.ole.docstore.model.enums.DocFormat;
import org.kuali.ole.docstore.model.enums.DocType;
import org.kuali.ole.docstore.model.repopojo.FolderNode;
import org.kuali.ole.docstore.model.repopojo.RepositoryData;
import org.kuali.ole.docstore.model.xmlpojo.ingest.Request;
import org.kuali.ole.docstore.model.xmlpojo.ingest.Response;
import org.kuali.ole.docstore.model.xstream.ingest.RequestHandler;
import org.kuali.ole.docstore.service.BeanLocator;
import org.kuali.ole.docstore.service.IngestNIndexHandlerService;
import org.kuali.ole.pojo.OleException;
import org.mockito.MockitoAnnotations;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import java.io.File;
import java.net.URL;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import static junit.framework.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

/**
 * Created by IntelliJ IDEA.
 * User: peris
 * Date: 5/23/11
 * Time: 10:20 AM
 * To change this template use File | Settings | File Templates.
 */
public class RepositoryBrowser_UT extends BaseTestCase
         {

    private static final Logger                     LOG                        = LoggerFactory
            .getLogger(RepositoryBrowser_UT.class);
    private              IngestNIndexHandlerService ingestNIndexHandlerService = BeanLocator
            .getIngestNIndexHandlerService();

    @Before
    public void setUp() throws Exception {
      //  super.setUp();
       // MockitoAnnotations.initMocks(this);
    }

             @Test
             public void testBrowseRepository() throws Exception {
                 RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
                 List<OleDocStoreData> oleDocStoreDatas = repositoryBrowser.browseDataSetup();
                 for (Iterator<OleDocStoreData> iterator = oleDocStoreDatas.iterator(); iterator.hasNext(); ) {
                     OleDocStoreData oleDocStoreData = iterator.next();
                     LOG.info(oleDocStoreData.getCategory());
                     Map<String, List<String>> typeFormatMap = oleDocStoreData.getTypeFormatMap();
                     Set<String> keys = typeFormatMap.keySet();
                     for (Iterator<String> stringIterator = keys.iterator(); stringIterator.hasNext(); ) {
                         String docType = stringIterator.next();
                         LOG.info(docType + ": " + typeFormatMap.get(docType));
                     }
                 }
             }

             @Test
             public void testGetRandomUUIDs() throws Exception {
                 URL url = this.getClass().getResource("repository/request.xml");
                 File file = new File(url.toURI());

                 String docStoreDocuments = ingestNIndexHandlerService.ingestNIndexRequestDocuments(readFile(file));
                 // System.out.println("testGetRandomUUIDs docStoreDocuments length "+docStoreDocuments);
                 assertTrue(!docStoreDocuments.isEmpty());
                 RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
                 List<String> uuiDs = repositoryBrowser
                         .getUUIDs(DocCategory.WORK.getCode(), DocType.BIB.getDescription(), DocFormat.MARC.getCode(),
                                   1);
                 System.out.println("testGetRandomUUIDs uuiDs length " + uuiDs.size());
                 if (uuiDs.size() > 0) {
                     Assert.assertNotNull(uuiDs);
                 }
                 uuiDs = repositoryBrowser.getUUIDs(DocCategory.WORK.getCode(), DocType.LICENSE.getDescription(),
                                                    DocFormat.ONIXPL.getCode(), 1);
                 System.out.println("uuiDs LICENSE" + uuiDs);
                 if (uuiDs.size() > 0) {
                     Assert.assertNotNull(uuiDs);
                 }
                 uuiDs = repositoryBrowser
                         .getUUIDs(DocCategory.WORK.getCode(), DocType.ITEM.getDescription(), DocFormat.OLEML.getCode(),
                                   1);
                 System.out.println("uuiDs ITEM" + uuiDs.size());
                 Assert.assertNotNull(uuiDs);
                 uuiDs = repositoryBrowser.getUUIDs(DocCategory.WORK.getCode(), DocType.HOLDINGS.getDescription(),
                                                    DocFormat.OLEML.getCode(), 1);
                 Assert.assertNotNull(uuiDs);
                 System.out.println("uuiDs HOLDING" + uuiDs.size());
                 for (Iterator<String> iterator = uuiDs.iterator(); iterator.hasNext(); ) {
                     String uuid = iterator.next();
                     LOG.info(uuid);
                 }
             }

             public void testGetUUIDs() {
                 try {
                     URL url = this.getClass().getResource("repository/request.xml");
                     File file = new File(url.toURI());

                     String docStoreDocuments = ingestNIndexHandlerService.ingestNIndexRequestDocuments(readFile(file));
                     //  System.out.println("testGetRandomUUIDs docStoreDocuments length "+docStoreDocuments);
                     assertTrue(!docStoreDocuments.isEmpty());
                     RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
                     List<String> uuiDs = repositoryBrowser
                             .getUUIDs(DocCategory.WORK.getCode(), DocType.BIB.getDescription(),
                                       DocFormat.MARC.getCode(), 1, 2);

                     System.out.println("testGetRandomUUIDs uuiDs length " + uuiDs.size());
                     assertTrue(!uuiDs.isEmpty());
                     uuiDs = repositoryBrowser.getUUIDs(DocCategory.WORK.getCode(), DocType.LICENSE.getDescription(),
                                                        DocFormat.ONIXPL.getCode(), 1, 1);

                     System.out.println("uuiDs LICENSE" + uuiDs);
                     //assertTrue(!uuiDs.isEmpty());
                     uuiDs = repositoryBrowser.getUUIDs(DocCategory.WORK.getCode(), DocType.ITEM.getDescription(),
                                                        DocFormat.OLEML.getCode(), 1, 1);
                     System.out.println("uuiDs ITEM" + uuiDs);
                     //   assertTrue(!uuiDs.isEmpty());
                     uuiDs = repositoryBrowser.getUUIDs(DocCategory.WORK.getCode(), DocType.HOLDINGS.getDescription(),
                                                        DocFormat.OLEML.getCode(), 1, 1);
                     System.out.println("uuiDs ITEM" + uuiDs);
                     for (Iterator<String> iterator = uuiDs.iterator(); iterator.hasNext(); ) {
                         String uuid = iterator.next();
                         LOG.info(uuid);
                     }
                 }
                 catch (Exception e) {
                     e.printStackTrace();
                 }
             }

    @Test
    public void testRepositoryNodeCount() throws Exception {
        // MarcIngester marcIngester = new MarcIngester();
        // marcIngester.setSolrIndexer(mockSolrIndexer);
        // URL url = this.getClass().getResource("sample.xml");
        // File file = new File(url.toURI());
        // List<RequestDocument> docStoreDocuments = marcIngester.ingestDocument(readFile(file));
        // assertTrue(!docStoreDocuments.isEmpty());

        RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
        List<OleDocStoreData> oleDocStoreDataList = repositoryBrowser.getFilesCount();
        assertNotNull(oleDocStoreDataList);
        for (Iterator<OleDocStoreData> iterator = oleDocStoreDataList.iterator(); iterator.hasNext(); ) {
            OleDocStoreData oleDocStoreData = iterator.next();
            Map<String, Map<String, Long>> typeFormatMapWithNodeCount = oleDocStoreData.getTypeFormatMapWithNodeCount();
            for (Iterator<String> oleDocStoreDataIterator = typeFormatMapWithNodeCount.keySet()
                                                                                      .iterator(); oleDocStoreDataIterator
                    .hasNext(); ) {
                String key = oleDocStoreDataIterator.next();
                LOG.info(key + ": " + typeFormatMapWithNodeCount.get(key));
            }
        }
    }

    @Test
    public void repoDump() throws RepositoryException, OleException {
        RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
        String dump = repositoryBrowser.getRepositoryDump();
        LOG.info("dump" + dump);
    }
    @Test
    public void getDetails() throws Exception{
          RepositoryManager repositoryManager = RepositoryManager.getRepositoryManager();
        Session session = repositoryManager.getSession("mockUser", "test");
        System.out.println("getName " + session.getWorkspace().getName());
    }

    @Ignore
    @Test
    public void getRepositoryDumpRange() throws Exception {
        RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
        String category = DocCategory.WORK.getCode();
        String type = DocType.BIB.getDescription();
        String format = DocFormat.MARC.getCode();
        int fromIndex = 1;
        int Count = 1;
        cleanRepository(category, type);
        String beforedump = repositoryBrowser.getRepositoryDump();
        LOG.info("beforedump" + beforedump);
        loadBulkMarcRecords(DocCategory.WORK.getCode(), DocType.BIB.getDescription(), DocFormat.MARC.getCode(),
                            "/org/kuali/ole/bulkhandler/OLE-Bib-bulkIngest-IU-Set1-split.xml");
        String dump = repositoryBrowser.getRepositoryDump();
        LOG.info("dump" + dump);
        String dumpRange = repositoryBrowser.getRepositoryRangeDump(category, type, format, fromIndex, Count);
        LOG.info("dumpRange" + dumpRange);
    }

    public void cleanRepository(String category, String type) throws OleException, RepositoryException {
        RepositoryManager repositoryManager = RepositoryManager.getRepositoryManager();
        Session session = repositoryManager.getSession("mockUser", "test");
        Node rootNode = session.getRootNode();
        Node catNode = rootNode.getNode(category);
        Node typeNode = catNode.getNode(type);
        for (Iterator<Node> typeiterator = typeNode.getNodes(); typeiterator.hasNext(); ) {
            Node formatNode = typeiterator.next();
            if (!formatNode.getName().equals("jcr:system")) {
                formatNode.remove();
            }
        }
        session.save();
        repositoryManager.logout(session);
    }

    private void loadBulkMarcRecords(String category, String type, String format, String inputXml) throws Exception {
        File file = new File(getClass().getResource("/org/kuali/ole/repository/request.xml").toURI());
        String input = FileUtils.readFileToString(file);
        RequestHandler rh = new RequestHandler();
        Request request = rh.toObject(input);
        Response response = ingestNIndexHandlerService.ingestNIndexRequestDocuments(request);

        // BulkLoadHandler bulkLoadHandler = new BulkLoadHandler();
        // assertNotNull(bulkLoadHandler);
        // List<String> recordUUIDs = bulkLoadHandler.loadBulk(category,
        // type,
        // format,
        // new File(getClass().getResource(inputXml).toURI()),
        // "testUser", "testLoadBulk");
        // assertNotNull(recordUUIDs);
        // Assert.assertTrue(!recordUUIDs.isEmpty());
        // for (Iterator<String> iterator = recordUUIDs.iterator(); iterator.hasNext(); ) {
        // String recordUUID = iterator.next();
        // LOG.info("recordUUID"+recordUUID);
        // }
    }

             @Test
             public void loadRepository() throws OleException, RepositoryException {
                 RepositoryManager oleRepositoryManager = RepositoryManager.getRepositoryManager();
                 RepositoryData repositoryData = new RepositoryData();
                 RepositoryBrowser repositoryBrowser = new RepositoryBrowser();
                 FolderNode folderNode = repositoryBrowser
                         .computeNodeCount(oleRepositoryManager.getSession().getRootNode(), repositoryData);
                 String repoDump = repositoryData.getRepositoryDump(repositoryData);
                 LOG.info("repoDump" + repoDump);
                 repositoryBrowser.browseRepositoryContent();
                 repositoryBrowser.generateNodeCount();
             }

         }