cassandra-trunk/test/unit/org/apache/cassandra/tools/SSTableExportSchemaLoadingTest.java
/*
 * 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.
 */

package org.apache.cassandra.tools;

import java.io.IOException;
import java.util.List;
import java.util.Map;

import org.junit.BeforeClass;
import org.junit.Test;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.exc.MismatchedInputException;
import org.apache.cassandra.utils.JsonUtils;
import org.assertj.core.api.Assertions;

import static org.hamcrest.CoreMatchers.startsWith;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

/**
 * Moved to separate class from SSTableExportTest to avoid schema getting loaded before
 * running a test where we don't expect the schema to be loaded
 */
public class SSTableExportSchemaLoadingTest extends OfflineToolUtils
{
    private static final ObjectMapper mapper = JsonUtils.JSON_OBJECT_MAPPER;
    private static final TypeReference<List<Map<String, Object>>> jacksonListOfMapsType = new TypeReference<List<Map<String, Object>>>() {};
    private static String sstable;

    @BeforeClass
    public static void setupTest() throws IOException
    {
        sstable = findOneSSTable("legacy_sstables", "legacy_ma_simple");
    }

    @Test
    public void testDefaultCall() throws IOException
    {
        ToolRunner.ToolResult tool = ToolRunner.invokeClass(SSTableExport.class, sstable);
        List<Map<String, Object>> parsed = mapper.readValue(tool.getStdout(), jacksonListOfMapsType);
        assertNotNull(tool.getStdout(), parsed.get(0).get("partition"));
        assertNotNull(tool.getStdout(), parsed.get(0).get("rows"));
        Assertions.assertThat(tool.getCleanedStderr()).isEmpty();
        tool.assertOnExitCode();
        assertPostTestEnv();
    }

    @Test
    public void testCQLRowArg()
    {
        ToolRunner.ToolResult tool = ToolRunner.invokeClass(SSTableExport.class, sstable, "-d");
        assertThat(tool.getStdout(), startsWith("[0]"));
        Assertions.assertThat(tool.getCleanedStderr()).isEmpty();
        tool.assertOnExitCode();
        assertPostTestEnv();
    }

    @Test
    public void testPKOnlyArg()
    {
        ToolRunner.ToolResult tool = ToolRunner.invokeClass(SSTableExport.class, sstable, "-e");
        assertEquals(tool.getStdout(), "[ [ \"0\" ], [ \"1\" ], [ \"2\" ], [ \"3\" ], [ \"4\" ]\n]", tool.getStdout());
        Assertions.assertThat(tool.getCleanedStderr()).isEmpty();
        tool.assertOnExitCode();
        assertPostTestEnv();
    }

    @Test
    public void testPKArg() throws IOException
    {
        ToolRunner.ToolResult tool = ToolRunner.invokeClass(SSTableExport.class, sstable, "-k", "0");
        assertKeys(tool, "0");
        assertPostTestEnv();
    }

    @Test
    public void testMultiplePKArg() throws IOException
    {
        ToolRunner.ToolResult tool = ToolRunner.invokeClass(SSTableExport.class, sstable, "-k", "0", "2");
        assertKeys(tool, "0", "2");
        assertPostTestEnv();
    }

    @Test
    public void testExcludePKArg() throws IOException
    {
        ToolRunner.ToolResult tool = ToolRunner.invokeClass(SSTableExport.class, sstable, "-x", "0");
        assertKeys(tool, "1", "2", "3", "4");
        assertPostTestEnv();
    }

    @Test
    public void testMultipleExcludePKArg() throws IOException
    {
        ToolRunner.ToolResult tool = ToolRunner.invokeClass(SSTableExport.class, sstable, "-x", "0", "2");
        assertKeys(tool, "1", "3", "4");
        assertPostTestEnv();
    }

    @SuppressWarnings("rawtypes")
    private void assertKeys(ToolRunner.ToolResult tool, String... expectedKeys) throws IOException
    {
        List<Map<String, Object>> parsed = mapper.readValue(tool.getStdout(), jacksonListOfMapsType);
        String[] actualKeys = parsed.stream()
                                    .map(x -> (Map) x.get("partition"))
                                    .map(x -> (List) x.get("key"))
                                    .map(x -> (String) x.get(0))
                                    .toArray(String[]::new);
        assertArrayEquals(expectedKeys, actualKeys);
        Assertions.assertThat(tool.getCleanedStderr()).isEmpty();
        tool.assertOnExitCode();
    }

    @Test
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public void testTSFormatArg() throws IOException
    {
        ToolRunner.ToolResult tool = ToolRunner.invokeClass(SSTableExport.class, sstable, "-t");
        List<Map<String, Object>> parsed = mapper.readValue(tool.getStdout(), jacksonListOfMapsType);
        assertEquals(tool.getStdout(),
                     "1445008632854000",
                     ((Map) ((List<Map>) parsed.get(0).get("rows")).get(0).get("liveness_info")).get("tstamp"));
        Assertions.assertThat(tool.getCleanedStderr()).isEmpty();
        tool.assertOnExitCode();
        assertPostTestEnv();
    }

    @Test
    @SuppressWarnings({ "rawtypes", "DynamicRegexReplaceableByCompiledPattern" })
    public void testJSONLineArg() throws IOException
    {
        ToolRunner.ToolResult tool = ToolRunner.invokeClass(SSTableExport.class, sstable, "-l");
        try
        {
            mapper.readValue(tool.getStdout(), jacksonListOfMapsType);
            fail("Shouldn't be able to deserialize that output, now it's not a collection anymore.");
        }
        catch (MismatchedInputException e)
        {
            assertThat(e.getMessage(), startsWith("Cannot deserialize"));
        }

        int parsedCount = 0;
        for (String jsonLine : tool.getStdout().split("\\R"))
        {
            Map line = mapper.readValue(jsonLine, Map.class);
            assertTrue(jsonLine, line.containsKey("partition"));
            parsedCount++;
        }

        assertEquals(tool.getStdout(), 5, parsedCount);
        assertThat(tool.getStdout(), startsWith("{\""));
        Assertions.assertThat(tool.getCleanedStderr()).isEmpty();
        tool.assertOnExitCode();
        assertPostTestEnv();
    }

    /**
     * Runs post-test assertions about loaded classed and started threads.
     *
     */
    private void assertPostTestEnv()
    {
        assertNoUnexpectedThreadsStarted(OPTIONAL_THREADS_WITH_SCHEMA, true);
        assertCLSMNotLoaded();
        assertSystemKSNotLoaded();
        assertKeyspaceNotLoaded();
        assertServerNotLoaded();
    }
}
