Changeset 511

Timestamp:

06/07/08 08:59:23 (7 months ago)

Author:

jmowery

Message:

update to storage tests

Files:

• branches/trunk-pmd-intproto/test/storage.tests (modified) (5 diffs)

branches/trunk-pmd-intproto/test/storage.tests

@@ -8 +8 @@
-        - add a directory recursively
-                + as above the control files and directories for the directory exist as does a copy of each file
+
-* remove
-        - remove a file
@@ -13 +14 @@
-        - remove a directory (always recursive)
-                + no control files or directories (see above) exist in the directory or any of its sub-directories
+
-* check-in
-        - no-op if no modified files
@@ -20 +22 @@
-        - if directory is locked should raise an exception
-                + raises a RuntimeError stating that the file (or directory) is locked
+
-* lock
-        - lock a file
+                + there exists a symbolic link with the name of the file in the directory
+                + the target of the link is a file in .__storage__/ named with the same stem
+                + the timestamp on the storage file matches the applied date of the file
-        - lock a directory
+                + the lock flag is set; the filesystem is unchanged
-        - lock a directory recursively
+                + the lock flag is set on the directory
+                + each controlled file is not a symbolic link to a versioned copy in .__storage__/
+                + each link's target matches the applied time of the file
-        - no-op to lock a locked file or directory
+                + if it would be legal to lock the file (i.e. if it weren't already locked), no exception should be raised
-        - raise an exception if attempting to lock a file in a locked directory
+                + raises a RuntimeError stating that the directory is locked
+
-* unlock
-        - unlock a file
+                + the symbolic link is replaced with a writeable copy of the file in .__storage__/ with the same stem and timestamp
-        - unlock a directory
+                + the lock flag is unset; the filesystem is unchanged
-        - unlock a directory recursively
+                + all of the symbolic links for controlled files are replaced as above
+                + the lock flag on the directory is unset
-        - no-op to unlock a file or directory that is not locked
+                + if it would be legal to lock the file (i.e. if it weren't already unlocked), no exception should be raised
-        - raise an exception if attempting to unlock a file in a locked directory
+                + raises a RuntimeError stating that the directory is locked
+
-* rollback
-        - rollback a file (default now)
+                + its applied time matches its latest time
-        - rollback a file to previous date
+                + if a storage copy exists with the exact date specified, the applied time will be set to that time
+                + if no exact match exists, the newest timestamp as of the specified date will be used
+                + if the specified date is before the initial time of the file, the applied time will be 0
-        - rollback a directory (default now)
+                + set the applied time for the directory to latest
+                + for each controlled file in the directory, preform the operations above for rolling files to present
-        - rollback a directory to previous date
+                + set the applied time for the directory to the specified date
+                + for each controlled file in the directory, perform the operations above for rolling files to a previous date
-        - rollback a directory recursively (default now)
+                + as with the non-recursive operation but also walking into all controlled sub-directories
-        - rollback a directory recursively to previous date
+                + as with the non-recursive operation but also walking into all controlled sub-directories
+
-* revisions
-        - list revisions of a file
+                + list contains the timestamp of each copy of the file in .__storage__/
-        - list revisions of a directory
+                + list contains each unique timestamp from all controlled files in .__storage__/
-        - list revisions of a directory recursively
+                + lists are returned for the directory and each controlled file in the directory
+                + also returns similar lists for each controlled sub-directory
-        - list revisions of an uncontrolled file
+                + returned dictionary is empty
-        - list revisions of an uncontrolled directory (recursive makes no differece here)
+                + returned dictionary is empty
+
-* status
-        - list status of a file
+                + returned list contains a string representing the status of the file's applied and modification status and relevant timestamps
-        - list status of a directory
+                + returned list contains a string for the directory and each controlled file in it
-        - list status of a directory recursively
+                + as with the non-recursive version except the returned list contains strings for each sub-directory and thier controlled files as well
-        - list status of an uncontrolled file
+                + returned list contains only a single string with no timestamps
-        - list status of an uncontrolled directory (recursive makes no differece here)
+                + returned list contains only a single string for the directory with no timestamp and no file status strings
+
-* export
-        - export a directory
-
-
+
+
+
+
+
-
-Layer Class
@@ -60 +107 @@
-* creation
-        - create with a legitimate path
+                + data for all entries is read and initialized from disk
-        - create with a path to uncontrolled directory
-
-
+
+
+
+
-* deletion
-        - asserts that the deleted layer is unmodified since last sync to disk
+                + due to Python's treatment of exceptions in destructors, this assertion will only print a warning and be ignored if violated
+
-* update
-        - no-op if unmodified or uncontrolled
+                + no change in on disk or in memory entries
-        - updates on disk data with all changes made
-                + the modified flag should be cleared after all calls
+
-* write
-        - no-op if uncontrolled
+                + no change in the .__status__ file
-        - write the current status to disk
-                + the modified flag should be cleared after all calls
+
-* rollback
-        - no-op if current directory is not controlled
+                + no change in the filesystem or the layer object
-        - default: current directory, now, non-recursive
+                + applied time for all controlled files and current directory are set to latest
-        - rollback a file to now
+                + specified file's applied time is set to latest
+                + no other entries are changed
-        - rollback a sub-directory to now
+                + no entries in current layer object are changed
+                + .__status__ file in the sub-directory has been modified
-        - rollback a sub-directory to now recursively
+                + as with the non-recursive version but all sub-directories have modified .__status__ files
+        - rollback a file to a previous date
+                + the applied date is set to the most recent as of the specified date
+                + if the specified date is before the initial time for that entry, the applied is set to 0
+        - rollback current directory to a previous date
+                + the applied time for the current directory is set to the specified date
+                + the applied time for all controlled files are set as above
+        - rollback a sub-directory to a previous date
+                + no change to local entries
+                + the .__status__ file in the sub-directory is updated
+        - rollback current directory to a previous date recursively
+                + as per the non-recursive version and all sub-directories are also processed
+
-* export
-        - no-op if current directory is not controlled
-
+
+
+
-        - export current directory (recursively) to destination directory
+                + copies of each file and sub-directory exist under destination path with no control files
+
-* get_current
-        - get path of current applied version of a file
+                + timestamp matches applied time for the file's entry
+                + file at the returned path actually exists
-        - get empty string for a directory or uncontrolled file
+                + empty string only returned in this case
+
-* get_latest
-        - get path of latest checked-in version of a file
+                + timestamp matches latest time for the file's entry
+                + file at the returned path actually exists
-        - get empty string for a directory or uncontrolled file
+                + empty string only returned in this case
+
-* is_modified
-        - unconditionally false for a directory
+                + returns False
-        - true for a file if its mtime is greater than its latest time
+                + only true in this case
+
-* checkin
-        - recursively add new version for every file modified under the current directory or any of its sub-directories
+                + new copy of any modified file exists in .__storage__/
+                + the latest time for any modified file's entry is updated
+                + the latest time for the containing directory is updated (only if at least one file changed)
-        - raise an exception if current directory is uncontrolled
+                + raises a RuntimeError stating that files may not be checked into an uncontrolled directory
+
-* add
-        - add a file
+                + layer contains an entry for the file
+                + a new copy exists in .__storage__/
+                + the latest time for the layer is updated
+                + the latest time for the file is updated
-        - add a directory
+                + control files are created in the directory
+                + an entry for '.' exists
+                + if the directory's parent is controlled, an entry for the current directory is added there
-        - add a file recursively when the current directory is uncontrolled
+                + entry for the file exists
+                + entry for '.' exists
+                + control files are created in the directory
+                + a copy of the file exists in .__storage__/
-        - add a directory recursively
+                + adds the directory
+                + adds each file in the directory
-        - raise an exception if file does not exist
+                + raises a ValueError stating the file does not exist
+        - raise an exception if current directory is uncontrolled and recursive flag is false
+                + raises a RuntimeError stating the above
-        - raise an exception if file is locked
+                + raises a RuntimeError stating the file is locked and cannot be modified
-        - raise an exception if current directory is locked
+                + raises a RuntimeError stating that the directory is locked and its files cannot be modified
+
-* remove
-        - no-op if current directory is uncontrolled or file is uncontrolled
+                + no filesystem changes
-        - remove a file
+                + the entry for the file in the layer object is removed
+                + all copies of the file in .__storage__/ are removed
+                + the file itself still exists
-        - remove a directory recursively
+                + remove all storage copies of files in the directory
+                + remove all entries
+                + remove control files
+                + repeat process for all sub-directories
-        - raise an exception if file is locked
+                + raises a RuntimeError stating the file is locked and cannot be modified
-        - raise an exception if current directory is locked
+                + raises a RuntimeError stating that the directory is locked and its files cannot be modified
+
-* control
-        - no-op if current is already controlled
+                + no filesystem changes
-        - create all control files for current directory
+                + all control files are created in current directory (.__status__, .__storage__/, .__nodes__/, and possibly .__logs__/ if it is the root)
+
-* clean
+        - raise an exception if the directory is not controlled
+                + raises a RuntimeError stating that uncontrolled directories cannot be cleaned
-        - raise an exception if file is not controlled
+                + raises a ValueError stating there is no entry for file
-        - clean a file
+                + all storage copies of file with timestamps newer than applied are deleted
+                + file's latest time is updated to applied
-        - clean a directory
+                + all controlled files in the directory are cleaned
+                + directory's latest entry is set to the newest latest entry of any file
-        - clean a directory recursively
+                + as with the non-recursive version but also operates on sub-directories
-        - no-op if file is applied at latest time
+                + no files are removed from .__storage__/
+
-* status_prefix
-        - return status prefix for a file
+                + returns a 6 character string the first and last of which are space
+                + the second is '!' if the file is not local, and space otherwise
+                + the third is one of the following in order of precedence:
+                        ~ 'D' if its applied date is less than its initial date
+                        ~ 'M' if the file has been modified since its last addition
+                        ~ 'N' if the file's applied time is newer than its parent directory's applied time
+                        ~ 'R' if its applied time is less than its latest time
+                        ~ space in all other cases
+                + the fourth is '.'
+                + the fifth is '&' if the file is locked and space otherwise
-        - return status prefix for an uncontrolled file
+                + returns exactly '  ?.  ' (two spaces, '?', '.', two spaces)
-        - return status prefix for current directory
+                + as with a controlled file except the fourth character is '-' (or '=' if current is a local customization directory)
-        - return status prefix for a sub-directory
+                + as with a controlled file except the fourth character is '+' (or '=' as above)
+
-* version_suffix
-        - return version time(s) for a controlled file or current directory
+                + returns a string starting with '@' followed by the applied time
+                + if the applied time is not the latest it will also contain a '/' followed by the latest time
+                + if the applied time is 0 the first timestamp will instead be the string 'DISABLED'
-        - return empty string for an uncontrolled file or a sub-directory
+                + returns empty string only in this case
+
-* status
-        - return status for a file
+                + return a list with one string per file of the form status_prefix, name, version_suffix
-        - return status for a directory (and its files)
+                + return a list of status strings as above first for the directory itself then each file in it (controlled and uncontrolled)
-        - return status for a directory recursively
+                + return a list as above for the directory then followed by each sub-directory (with its files) in order
-        - raise an exception if file does not exist
+                + raises a RuntimeError stating that the file does not exist
+
-* revisions
-
+
+
-        - return dictionary with name and revisions list for a file
+                + dictionary contains key of file name and value of a list of all revisions of that file
+                + each revision in the list has a corresponding file in .__storage__/
+                + all files with the same stem in .__storage__/ have a timestamp in the returned list
-        - return dictionary with name and revisions list for each file in a directory
+                + dictionary contains an entry for '.' with a list of all unique timestamps
+                + also contains one entry for each controlled file as above
+
-* list_controlled_files
-        - return list of files under revision control
+                + all returned files have at least one copy in .__storage__/
+                + all unique file stems in .__storage__/ appear in the list
-        - return empty list if current directory is uncontrolled
+
-* list_local_newer
-        - return a list of files with applied times later than the directory
+                + only newer files appear in the list
+                + all newer files appear in the list
+
-* list_controlled_dirs
-        - return a list of controlled sub-directories
+                + all directories with control files under the current directory appear in the list
+
-* list_controlled
-        - return a list of all controlled files and directories
+                + combined list of list_controlled_files and list_controlled_dirs
+
-* lock
-        - no-op if file or directory is already locked
+                + no filesystem changes
-        - lock a file
+                + file is replaced by a symbolic link to the applied version in .__storage__/
-        - lock a directory
+                + if recursive, lock all controlled files
+                + set the directory's lock flag
-        - raise an exception if attempting to lock a file in a locked directory
+                + raises a RuntimeError stating that the directory is locked and its files cannot be modified
+
-* unlock
-        - no-op if file or directory is not locked
+                + no filesystem changes
-        - unlock a locked file
+                + symbolic link is replaced by a writeable copy of its former target
-        - unlock a locked directory
+                + unset the directory's lock flag
+                + if recursive, unlock all controlled files
-        - raise an exception if attempting to unlock a locked file in a locked directory
+                + raises a RuntimeError stating that the directory is locked and its files cannot be modified
+
-* is_locked
-        - return true if file or directory is locked
+                + only true in this case
-        - return true if any file under a directory is locked when called recursively
+                + only true in this case
+
-* add_node //NOTE: this is an internal function
-        - add a node
-                + adds the appropriate file (named by node IP) to a layer's .__nodes__/ directory
+
-* list_nodes
-        - list nodes in a directory
+                + all nodes listed have a corresponding file in .__nodes__/
+                + all nodes with a corresponding file in .__nodes__/ appear in the list
+
-* get_node
-        - get a Node object for a node in the current directory
+                + if the node exists return a node object; return None otherwise
+
-* append_log_messages
-        - applied a list of messages to the log for a given node
+                + the log file in the root directory's .__logs__/ directory will be modified
+                + the log file's size only increases
+
-* get_log_messages
-        - get a list of all messages recorded for a single node
+                + all messages appended previously are returned
+
-* clear_log
-        - clear the list of messages for a single node
+                + the log file should be empty
+
-* get_entry
-        - get the entry for a controlled file or sub-directory
+                + returns a valid entry object
-        - return none for uncontrolled files or sub-directories
+                + only returns None in this case
-
-Node Class
@@ -178 +387 @@
-* creation
-        - given an id and the root of storage, return an existing node object
+                + object is initialized and correctly detects its classification
-        - given a new id and the root of storage, return a new unclassified node object
+                + entries, bools, layers, and classification are all empty
-        - given a new id and the root of storage and a classification, return a new node classified as requested
+                + node will appear in each layer in the classification's .__nodes__/ directory
+                + entries will contain an entry for each file in those layers with a 0 applied time
+                + layers will contain an entry for each layer in classification
+
-* deletion
-        - asserts the deleted node is unmodified since last sync to disk
+                + due to Python's treatment of exceptions in destructors, this assertion will only print a warning and be ignored if violated
+
-* list_layers
-        - return an ordered list of the paths of all layers containing the node
+                + list includes all layers in classification
+
-* check_updates
-        - return a dictionary of names to be updated and the file to be sent (empty for deletion)
+                + unless all entries applied times match the appropriate layer's entry's applied time, storage path for each file with a different applied time
+
-* write
-        - write the data to disk
+                + the appropriate files in .__nodes__/ are modified
+
-* set_file_status
-        - set the status of a file sent to a node
+                + sets the applied time for the entry to the timestamp of the sent file
-        - raise an exception if file does not exist or is uncontrolled
+                + raises a ValueError stating that the file does not have an entry in the given layer
-        - raise an exception if attempting to add local customizations to directories other than the local customization directory for that node
+                + raises a RuntimeError stating that local customizations can only occur in the appropriate directory
+
-* set_bool_status
-        - record the state of a boolean
+                + adds the boolean with the value recorded to bools
+
-* update
-        - no-op if unmodified
+                + no filesystem changes
-        - updates on disk data with all changes made
-                + the modified flag should be cleared after all calls
+
-* classify
-        - with no argument, calculate the classification of a node
+                + final component of classification should be the id of the node
+                + all controlled files in each layer in classification should have an entry
-        - with a group name, reclassify the node so that the leaf in the hierarchy is under group's layer
+                + the directory with the name matching the node id will be moved to (or created at) the leaf of the classification tree
+                + all layers part of both the new and old classification should be unchanged
+                + the status of local customizations should be unchanged
+                + all entries for files not present in any layer of the new classification should be removed
+                + entries for all files in the new layers should exist