1 #

     2 # Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 # All rights reserved.

     4 # This component and the accompanying materials are made available

     5 # under the terms of "Eclipse Public License v1.0"

     6 # which accompanies this distribution, and is available

     7 # at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 #

     9 # Initial Contributors:

    10 # Nokia Corporation - initial contribution.

    11 #

    12 # Contributors:

    13 #

    14 # Description: 

    15 #

    16 

    17 

    18 """

    19 Test the CPF root file parsing routines

    20 """

    21 

    22 import zipfile

    23 import unittest

    24 import string

    25 import sys,os,shutil

    26 ROOT_PATH = os.path.dirname(os.path.abspath(__file__))

    27 

    28 import __init__

    29 from cone.public.exceptions import NotResource,StorageException

    30 from cone.public import api 

    31 from cone.storage import filestorage

    32 

    33 datafolder= ROOT_PATH

    34 datazip   = os.path.join(ROOT_PATH,"data.zip")

    35 datafolder= os.path.join(ROOT_PATH,"data")

    36 

    37 

    38 class TestFileStorageCreation(unittest.TestCase):    

    39     def setUp(self):

    40         pass

    41 

    42     def test_create_storage_on_non_existing_path_fails(self):

    43         try:

    44             storage = filestorage.FileStorage("dummydatafolder")

    45             self.fail("opening on dummydatafolder succeeds?")

    46         except StorageException,e:

    47             self.assertTrue(True)

    48 

    49     def test_create_storage_on_file_fails(self):

    50         try:

    51             storage = filestorage.FileStorage(datazip)

    52             self.fail("opening on data file succeeds?")

    53         except StorageException,e:

    54             self.assertTrue(True)

    55 

    56     def test_create_storage_on_new_directory(self):

    57         storage = filestorage.FileStorage("dummytest/storage","w")

    58         self.assertTrue(os.path.exists("dummytest/storage"))

    59         shutil.rmtree("dummytest")

    60 

    61 class TestFileStorage(unittest.TestCase):    

    62     def setUp(self):

    63         self.storage = filestorage.FileStorage(datafolder)

    64 

    65     def test_supported_storage(self):        

    66         self.assertTrue(filestorage.FileStorage.supported_storage("C:/GenerationRegressionTest/wc/genregtest_workdir/cone_vs_ct2/pf7132_020.006/config_project/"))

    67         self.assertTrue(filestorage.FileStorage.supported_storage("C:/GenerationRegressionTest/wc/genregtest_workdir"))

    68         self.assertFalse(filestorage.FileStorage.supported_storage("C:/GenerationRegressionTest/wc/genregtest_workdir.zip"))

    69     

    70     def test_open_resource_existing_file_for_reading(self):

    71         res = self.storage.open_resource("simple.confml")

    72         self.assertTrue(res)

    73         self.assertTrue(isinstance(res,api.Resource))

    74 

    75     def test_open_resource_new_file(self):

    76         res = self.storage.open_resource("newfile.txt","w")

    77         self.assertTrue(res)

    78         self.assertTrue(isinstance(res,api.Resource))

    79         res.close()

    80         self.assertTrue(os.path.exists(datafolder+"/newfile.txt"))

    81         os.remove(datafolder+"/newfile.txt")

    82 

    83     def test_list_resources(self):

    84         self.assertEquals(self.storage.list_resources("."),

    85                           ['.metadata', 'morestuff.confml', 'prodX.confml', 'simple.confml'])

    86         

    87     def test_delete_resource(self):

    88         tf = open(os.path.join(datafolder,"tempfile.txt"),"w")

    89         tf.close()

    90         res = self.storage.delete_resource("tempfile.txt")

    91         self.assertFalse(os.path.exists(datafolder+"tempfile.txt"))

    92         

    93     def test_open_resource_nonexisting(self):

    94         try:

    95             res = self.storage.open_resource("iamnothere.txt")

    96             self.fail("Opening of a non existing file succeeds!??")

    97         except NotResource: 

    98             self.assertTrue(True)

    99 

   100     def test_list_resources_nonrecurse(self):

   101         file_array = self.storage.list_resources("")

   102         self.assertEquals(file_array[0],".metadata")

   103 

   104     def test_list_resources_nonrecurse_from_root(self):

   105         file_array = self.storage.list_resources("/")

   106         self.assertTrue(file_array.index(".metadata")==0)

   107 

   108     def test_list_resources_recurse_from_root(self):

   109         file_array = self.storage.list_resources("",True)

   110         self.assertEquals(file_array[0],".metadata")

   111 

   112     def test_list_resources_from_subfolder(self):

   113         file_array = self.storage.list_resources("familyX")

   114         self.assertEquals(file_array[0],"familyX/root.confml")

   115 

   116     def test_list_resources_recurse_from_subfolder(self):

   117         file_array = self.storage.list_resources("familyX", True)

   118         self.assertEquals(file_array[0],"familyX/root.confml")

   119         # Count only non-SVN files

   120         self.assertEquals(len(filter(lambda x: x.find('.svn') == -1, file_array)), 7)

   121 

   122     def test_is_resource_true(self):

   123         self.assertTrue(self.storage.is_resource("simple.confml"))

   124 

   125     def test_is_resource_true_with_begin_slash(self):

   126         self.assertTrue(self.storage.is_resource("/simple.confml"))

   127 

   128     def test_is_resource_false(self):

   129         self.assertFalse(self.storage.is_resource("data"))

   130 

   131     def test_open_resource_existing_file_with_root(self):

   132         res = self.storage.open_resource("/simple.confml")

   133         self.assertTrue(res)

   134         self.assertTrue(isinstance(res,api.Resource))

   135 

   136     def test_metadata_writing(self):

   137         fs = filestorage.FileStorage("testtemp","w")

   138         fs.set_active_configuration('testing.confml')

   139         fs.close()

   140         fs = filestorage.FileStorage("testtemp","r")

   141         self.assertEquals(fs.get_active_configuration(),'testing.confml')

   142         fs.close()

   143         shutil.rmtree("testtemp")

   144 

   145     def test_create_folder(self):

   146         store = filestorage.FileStorage("newtestfolder","w")

   147         store.create_folder("subdir")

   148         self.assertTrue(store.is_folder("subdir"))

   149         self.assertTrue(os.path.exists("newtestfolder/subdir"))

   150         store.create_folder('foo')

   151         layer = api.Folder(store, "foo")

   152         self.assertTrue(store.is_folder("foo"))

   153         self.assertTrue(layer)

   154         self.assertTrue(os.path.exists("newtestfolder/subdir"))

   155         layer.create_folder("foosubdir")

   156         self.assertTrue(store.is_folder("foo/foosubdir"))

   157         self.assertTrue(os.path.exists("newtestfolder/foo/foosubdir"))

   158         shutil.rmtree('newtestfolder')

   159 

   160 if __name__ == '__main__':

   161       unittest.main()