carbondata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ravipes...@apache.org
Subject [1/3] incubator-carbondata git commit: test case for columnar package and manage package for filesystem
Date Mon, 12 Dec 2016 05:56:40 GMT
Repository: incubator-carbondata
Updated Branches:
  refs/heads/master 61fe6d462 -> ddeb5e121


http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/4afef29b/core/src/test/java/org/apache/carbondata/core/datastorage/store/filesystem/LocalCarbonFileTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/datastorage/store/filesystem/LocalCarbonFileTest.java
b/core/src/test/java/org/apache/carbondata/core/datastorage/store/filesystem/LocalCarbonFileTest.java
new file mode 100644
index 0000000..6b644dd
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/datastorage/store/filesystem/LocalCarbonFileTest.java
@@ -0,0 +1,468 @@
+/*
+ * 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.carbondata.core.carbon.datastorage.filesystem;
+
+import mockit.Mock;
+import mockit.MockUp;
+import org.apache.carbondata.core.datastorage.store.filesystem.CarbonFile;
+import org.apache.carbondata.core.datastorage.store.filesystem.CarbonFileFilter;
+import org.apache.carbondata.core.datastorage.store.filesystem.LocalCarbonFile;
+import org.apache.carbondata.core.datastorage.store.impl.FileFactory;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import sun.nio.ch.FileChannelImpl;
+
+import java.io.*;
+import java.nio.channels.ReadableByteChannel;
+import java.util.Objects;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+
+public class LocalCarbonFileTest {
+
+    private static LocalCarbonFile localCarbonFile;
+    private static File file;
+    private static File dir;
+    private static FileOutputStream oFile;
+
+    @BeforeClass
+    static public void setUp() {
+        file = new File("Test.carbondata");
+        dir = new File("Testdir.carbondata");
+        if (!file.exists())
+            try {
+                file.createNewFile();
+                dir.mkdir();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        try {
+            oFile = new FileOutputStream(file, true);
+
+
+            byte[] bytes = "core java api".getBytes();
+
+            oFile.write(bytes);
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+            localCarbonFile = new LocalCarbonFile(file);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @AfterClass
+    static public void cleanUp() {
+        file.delete();
+        dir.delete();
+
+    }
+
+    @Test
+    public void testListFilesWithCarbonFileFilterAndWithOutOutDirectoryPermission() {
+        CarbonFileFilter carbonFileFilter = new CarbonFileFilter() {
+            @Override
+            public boolean accept(CarbonFile file) {
+                return false;
+            }
+        };
+        new MockUp<File>() {
+            @Mock
+            public boolean isDirectory() {
+                return false;
+            }
+
+
+        };
+        assertTrue(localCarbonFile.listFiles(carbonFileFilter) == null);
+    }
+
+    @Test
+    public void testListFilesWithOutDirPermission() {
+        localCarbonFile = new LocalCarbonFile(file);
+        new MockUp<File>() {
+            @Mock
+            public boolean isDirectory() {
+                return false;
+            }
+        };
+        assertTrue(localCarbonFile.listFiles() == null);
+    }
+
+    @Test
+    public void testCreateNewFileForException() throws IOException {
+        localCarbonFile = new LocalCarbonFile(new File(""));
+        assertTrue(!localCarbonFile.createNewFile());
+    }
+
+    @Test
+    public void testCheckIfFileExists() throws IOException {
+        localCarbonFile = new LocalCarbonFile(new File(""));
+        assertTrue(!localCarbonFile.exists());
+    }
+
+    @Test
+    public void testRenameForce() {
+        localCarbonFile = new LocalCarbonFile(file);
+        assertTrue(localCarbonFile.renameForce("Testdb.carbon"));
+    }
+
+    @Test
+    public void testRenameTo() {
+        localCarbonFile = new LocalCarbonFile(file);
+        assertTrue(!localCarbonFile.renameTo("Testdb.carbon"));
+    }
+
+    @Test
+    public void testsetLastModifiedTime() {
+        localCarbonFile = new LocalCarbonFile(file);
+        assertTrue(!localCarbonFile.setLastModifiedTime(50L));
+    }
+
+    @Test
+    public void testtruncate() {
+        localCarbonFile = new LocalCarbonFile(file);
+        final int[] counter = {0};
+        new MockUp<FileFactory>() {
+            @Mock
+            public FileFactory.FileType getFileType(String path) {
+                {
+                    return FileFactory.FileType.LOCAL;
+                }
+            }
+        };
+        new MockUp<FileFactory>() {
+            @Mock
+            public boolean isFileExist(String filePath, FileFactory.FileType fileType) throws
IOException {
+                {
+                    return true;
+                }
+            }
+        };
+        new MockUp<CarbonFile>() {
+            @Mock
+            boolean delete() {
+                return true;
+            }
+        };
+        new MockUp<FileFactory>() {
+            @Mock
+            public boolean createNewFile(String filePath, FileFactory.FileType fileType)
throws IOException {
+                {
+                    return true;
+                }
+            }
+        };
+        new MockUp<FileFactory>() {
+            @Mock
+            public CarbonFile getCarbonFile(String path, FileFactory.FileType fileType) {
+                {
+                    return new LocalCarbonFile(path);
+                }
+            }
+        };
+        new MockUp<CarbonFile>() {
+            @Mock
+            boolean delete() {
+                return true;
+            }
+        };
+
+        new MockUp<FileChannelImpl>() {
+            @Mock
+            public long transferFrom(ReadableByteChannel var1, long var2, long var4) throws
IOException {
+                if (counter[0] == 0) {
+                    counter[0] = counter[0] + 1;
+                    return 0L;
+                } else {
+                    return 1L;
+                }
+            }
+        };
+        new MockUp<CarbonFile>() {
+            @Mock
+            boolean renameForce(String changetoName) {
+                return true;
+            }
+        };
+        localCarbonFile = new LocalCarbonFile(file);
+        assertTrue(localCarbonFile.truncate(file.getName(), 1L));
+    }
+
+    @Test
+    public void testtruncateForException() throws IOException {
+        localCarbonFile = new LocalCarbonFile(file);
+        new MockUp<FileFactory>() {
+            @Mock
+            public FileFactory.FileType getFileType(String path) {
+                {
+                    return FileFactory.FileType.LOCAL;
+                }
+            }
+        };
+        new MockUp<FileFactory>() {
+            @Mock
+            public boolean isFileExist(String filePath, FileFactory.FileType fileType) throws
IOException {
+                {
+                    return true;
+                }
+            }
+        };
+        new MockUp<FileFactory>() {
+            @Mock
+            public CarbonFile getCarbonFile(String path, FileFactory.FileType fileType) {
+                {
+                    return new LocalCarbonFile(path);
+                }
+            }
+        };
+        new MockUp<CarbonFile>() {
+            @Mock
+            boolean delete() {
+                return true;
+            }
+        };
+        new MockUp<FileFactory>() {
+            @Mock
+            public boolean createNewFile(String filePath, FileFactory.FileType fileType)
throws IOException {
+                {
+                    throw new IOException();
+                }
+            }
+        };
+
+
+        localCarbonFile.truncate(file.getName(), 2L);
+    }
+
+    @Test
+    public void testListFilesWithDirPermission() {
+        localCarbonFile = new LocalCarbonFile(file);
+        new MockUp<File>() {
+            @Mock
+            public boolean isDirectory() {
+                return true;
+            }
+        };
+        new MockUp<File>() {
+            @Mock
+            public File[] listFiles() {
+                return null;
+            }
+
+
+        };
+        localCarbonFile = new LocalCarbonFile(dir);
+        assertTrue(localCarbonFile.listFiles().length == 0);
+    }
+
+    @Test
+    public void testListFilesWithCarbonFileFilterAndDirectoryPermission() {
+        CarbonFileFilter carbonFileFilter = new CarbonFileFilter() {
+            @Override
+            public boolean accept(CarbonFile file) {
+                return true;
+            }
+        };
+        new MockUp<File>() {
+            @Mock
+            public boolean isDirectory() {
+                return true;
+            }
+        };
+        new MockUp<File>() {
+            @Mock
+            public File[] listFiles(FileFilter filter) {
+
+                File[] file = new File[]{dir};
+                return file;
+            }
+
+
+        };
+
+        localCarbonFile = new LocalCarbonFile(dir);
+
+        assertTrue(localCarbonFile.listFiles(carbonFileFilter).length == 1);
+    }
+
+    @Test
+    public void testListFilesForNullWithCarbonFileFilterAndDirectoryPermission() {
+        CarbonFileFilter carbonFileFilter = new CarbonFileFilter() {
+            @Override
+            public boolean accept(CarbonFile file) {
+                return true;
+            }
+        };
+        new MockUp<File>() {
+            @Mock
+            public File[] listFiles(FileFilter filter) {
+                return null;
+            }
+
+
+        };
+        new MockUp<File>() {
+            @Mock
+            public boolean isDirectory() {
+                return false;
+            }
+
+            @Mock
+            public File[] listFiles(FileFilter filter) {
+                return null;
+            }
+
+
+        };
+        localCarbonFile = new LocalCarbonFile(dir);
+
+        assertTrue(localCarbonFile.listFiles(carbonFileFilter) == null);
+    }
+
+    @Test
+    public void testListFilesForEmptyFileArrayWithCarbonFileFilter() {
+        CarbonFileFilter carbonFileFilter = new CarbonFileFilter() {
+            @Override
+            public boolean accept(CarbonFile file) {
+                return true;
+            }
+        };
+        new MockUp<CarbonFileFilter>() {
+            @Mock
+            boolean accept(CarbonFile file) {
+                return true;
+            }
+        };
+        new MockUp<File>() {
+            @Mock
+            public File[] listFiles(FileFilter filter) {
+                return null;
+            }
+        };
+        new MockUp<File>() {
+            @Mock
+            public boolean isDirectory() {
+                return true;
+            }
+
+            @Mock
+            public File[] listFiles(FileFilter filter) {
+                return null;
+            }
+        };
+        localCarbonFile = new LocalCarbonFile(dir);
+
+        assertTrue(localCarbonFile.listFiles(carbonFileFilter).length == 0);
+    }
+
+    @Test
+    public void testFilesForConnicalPath() {
+
+        new MockUp<File>() {
+            @Mock
+            public String getCanonicalPath() throws IOException {
+                return "testFile";
+            }
+
+
+        };
+        localCarbonFile = new LocalCarbonFile(dir);
+
+        assertTrue(Objects.equals(localCarbonFile.getCanonicalPath(), "testFile"));
+    }
+
+    @Test
+    public void testFilesForConnicalPathException() throws IOException {
+
+        new MockUp<File>() {
+            @Mock
+            public String getCanonicalPath() throws IOException {
+                throw new IOException();
+            }
+
+
+        };
+        localCarbonFile = new LocalCarbonFile(dir);
+
+        localCarbonFile.getCanonicalPath();
+    }
+
+    @Test
+    public void testFilesForAbsolutePath() {
+
+        new MockUp<File>() {
+            @Mock
+            public String getAbsolutePath() {
+                return "testFile";
+            }
+
+
+        };
+        localCarbonFile = new LocalCarbonFile(dir);
+
+        assertEquals(localCarbonFile.getAbsolutePath(), "testFile");
+    }
+
+    @Test
+    public void testFilesForGetPath() {
+
+        new MockUp<File>() {
+            @Mock
+            public String getPath() {
+                return "testFile";
+            }
+
+
+        };
+        localCarbonFile = new LocalCarbonFile(dir);
+
+        assertEquals(localCarbonFile.getPath(), "testFile");
+    }
+
+    @Test
+    public void testFilesForFileExists() {
+
+        localCarbonFile = new LocalCarbonFile(new File(""));
+        assertEquals(localCarbonFile.exists(), false);
+    }
+
+    @Test
+    public void testRenameForceForFileNotExists() {
+        new MockUp<File>() {
+            @Mock
+            public boolean exists() {
+                return false;
+            }
+
+            @Mock
+            public boolean renameTo(File dest) {
+                return true;
+            }
+        };
+
+        localCarbonFile = new LocalCarbonFile("demo.txt");
+
+        assertEquals(localCarbonFile.renameForce("Test.carbondata"), true);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/4afef29b/core/src/test/java/org/apache/carbondata/core/datastorage/store/filesystem/ViewFsCarbonFileTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/datastorage/store/filesystem/ViewFsCarbonFileTest.java
b/core/src/test/java/org/apache/carbondata/core/datastorage/store/filesystem/ViewFsCarbonFileTest.java
new file mode 100644
index 0000000..5637b3c
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/datastorage/store/filesystem/ViewFsCarbonFileTest.java
@@ -0,0 +1,314 @@
+/*
+ * 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.carbondata.core.carbon.datastorage.filesystem;
+
+import mockit.Mock;
+import mockit.MockUp;
+import org.apache.carbondata.core.datastorage.store.filesystem.CarbonFile;
+import org.apache.carbondata.core.datastorage.store.filesystem.CarbonFileFilter;
+import org.apache.carbondata.core.datastorage.store.filesystem.ViewFSCarbonFile;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FileStatus;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.fs.viewfs.ViewFileSystem;
+import org.apache.hadoop.hdfs.DistributedFileSystem;
+import org.apache.hadoop.hdfs.web.WebHdfsFileSystem;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+public class ViewFsCarbonFileTest {
+
+    private static ViewFSCarbonFile viewFSCarbonFile;
+    private static FileStatus fileStatus;
+    private static FileStatus fileStatusWithOutDirectoryPermission;
+    private static String fileName;
+    private static File file;
+
+
+    @BeforeClass
+    static public void setUp() {
+        file = new File("Test.carbondata");
+        if (!file.exists())
+            try {
+                file.createNewFile();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        try {
+            FileOutputStream oFile = new FileOutputStream(file, true);
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        fileStatus = new FileStatus(12L, true, 60, 120l, 180L, new Path(file.getAbsolutePath()));
+        fileStatusWithOutDirectoryPermission = new FileStatus(12L, false, 60, 120l, 180L,
new Path(file.getAbsolutePath()));
+        fileName = file.getAbsolutePath();
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatus);
+    }
+
+    @AfterClass
+    static public void cleanUp() {
+        file.delete();
+    }
+
+    @Test
+    public void testRenameForceForException() throws IOException {
+
+        new MockUp<Path>() {
+            @Mock
+            public FileSystem getFileSystem(Configuration conf) throws IOException {
+                throw new IOException();
+            }
+
+        };
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatus);
+        viewFSCarbonFile.renameForce(fileName);
+    }
+
+    @Test
+    public void testListFilesWithOutDirectoryPermission() {
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatusWithOutDirectoryPermission);
+        assertTrue(viewFSCarbonFile.listFiles() == null);
+    }
+
+    @Test
+    public void testConstructorWithFilePath() {
+        viewFSCarbonFile = new ViewFSCarbonFile(file.getAbsolutePath());
+        assertTrue(viewFSCarbonFile instanceof ViewFSCarbonFile);
+    }
+
+    @Test
+    public void testListFilesForNullListStatus() {
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatusWithOutDirectoryPermission);
+        new MockUp<Path>() {
+            @Mock
+            public FileSystem getFileSystem(Configuration conf) throws IOException {
+                return new ViewFileSystem();
+            }
+
+        };
+        new MockUp<ViewFileSystem>() {
+            @Mock
+            public FileStatus[] listStatus(Path var1) throws IOException {
+
+                return null;
+            }
+
+        };
+        new MockUp<ViewFileSystem>() {
+            @Mock
+            public boolean delete(Path var1, boolean var2) throws IOException {
+
+                return true;
+            }
+
+        };
+        //public boolean delete(Path var1, boolean var2) throws IOException;
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatus);
+        assertTrue(viewFSCarbonFile.listFiles().length == 0);
+    }
+
+    @Test
+    public void testListDirectory() {
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatus);
+        new MockUp<Path>() {
+            @Mock
+            public FileSystem getFileSystem(Configuration conf) throws IOException {
+                return new ViewFileSystem();
+            }
+
+        };
+        new MockUp<ViewFileSystem>() {
+            @Mock
+            public FileStatus[] listStatus(Path var1) throws IOException {
+
+                FileStatus[] fileStatus = new FileStatus[]{new FileStatus(12L, true, 60,
120l, 180L, new Path(fileName))};
+                return fileStatus;
+            }
+
+        };
+
+        assertTrue(viewFSCarbonFile.listFiles().length == 1);
+    }
+
+    @Test
+    public void testListFilesForException() throws IOException {
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatusWithOutDirectoryPermission);
+
+        new MockUp<FileStatus>() {
+            @Mock
+            public Path getPath() {
+                return new Path(file.getAbsolutePath());
+            }
+
+        };
+        new MockUp<Path>() {
+            @Mock
+            public FileSystem getFileSystem(Configuration conf) throws IOException {
+                throw new IOException();
+            }
+
+        };
+        new MockUp<ViewFileSystem>() {
+            @Mock
+            public FileStatus[] listStatus(Path var1) throws IOException {
+
+                throw new IOException();
+            }
+
+        };
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatus);
+        viewFSCarbonFile.listFiles();
+    }
+
+    @Test
+    public void testListFilesWithCarbonFilter() {
+        CarbonFileFilter carbonFileFilter = new CarbonFileFilter() {
+
+            @Override
+            public boolean accept(CarbonFile file) {
+                return true;
+            }
+        };
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatus);
+        assertTrue(viewFSCarbonFile.listFiles(carbonFileFilter).length == 1);
+    }
+
+    @Test
+    public void testlistFilesWithoutFilter() {
+        CarbonFileFilter carbonFileFilter = new CarbonFileFilter() {
+
+            @Override
+            public boolean accept(CarbonFile file) {
+                return false;
+            }
+        };
+        new MockUp<Path>() {
+            @Mock
+            public FileSystem getFileSystem(Configuration conf) throws IOException {
+                return new ViewFileSystem();
+            }
+
+        };
+        new MockUp<ViewFileSystem>() {
+            @Mock
+            public FileStatus[] listStatus(Path var1) throws IOException {
+
+                FileStatus[] fileStatus = new FileStatus[]{new FileStatus(12L, true, 60,
120l, 180L, new Path(fileName))};
+                return fileStatus;
+            }
+
+        };
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatus);
+        assertTrue(viewFSCarbonFile.listFiles(carbonFileFilter).length == 0);
+    }
+
+    @Test
+    public void testGetParentFIle() {
+        new MockUp<Path>() {
+            @Mock
+            public FileSystem getFileSystem(Configuration conf) throws IOException {
+                return new DistributedFileSystem();
+            }
+
+        };
+        new MockUp<Path>() {
+            @Mock
+            public Path getParent() {
+                return new Path(file.getAbsolutePath()
+                );
+            }
+
+        };
+        new MockUp<FileStatus>() {
+            @Mock
+            public Path getPath() {
+                return new Path(file.getAbsolutePath());
+            }
+
+        };
+        new MockUp<DistributedFileSystem>() {
+            @Mock
+            public FileStatus getFileStatus(Path f) throws IOException {
+
+                return new FileStatus(12L, true, 60, 120l, 180L, new Path(file.getAbsolutePath()));
+            }
+
+        };
+
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatus);
+        assertFalse(viewFSCarbonFile.getParentFile().equals(null));
+    }
+
+    @Test
+    public void testForNonDisributedSystem() {
+        viewFSCarbonFile = new ViewFSCarbonFile(fileStatus);
+        new MockUp<Path>() {
+            @Mock
+            public FileSystem getFileSystem(Configuration conf) throws IOException {
+                return new WebHdfsFileSystem();
+            }
+
+        };
+        assertFalse(viewFSCarbonFile.renameForce(fileName));
+    }
+
+    @Test
+    public void testrenameForceForViewFileSystem() {
+        new MockUp<Path>() {
+            @Mock
+            public FileSystem getFileSystem(Configuration conf) throws IOException {
+                return new ViewFileSystem();
+            }
+
+        };
+        new MockUp<ViewFileSystem>() {
+            @Mock
+            public boolean delete(Path f, boolean recursive) throws
+                    IOException {
+                return true;
+
+            }
+
+        };
+        new MockUp<ViewFileSystem>() {
+            @Mock
+            public boolean rename(Path src, Path dst) throws IOException {
+                return true;
+
+            }
+
+        };
+
+        assertTrue(viewFSCarbonFile.renameForce(fileName));
+
+    }
+}


Mime
View raw message