git-ds 0.9.2

data/tests/ut_repo.rb

@@ -0,0 +1,260 @@
+#!/usr/bin/env ruby
+# Copyright 2010 Thoughtgang <http://www.thoughtgang.org>
+# Unit test for Git-DS Repo class
+
+require 'test/unit'
+require 'fileutils'
+
+require 'git-ds/repo'
+
+class TC_GitRepoTest < Test::Unit::TestCase
+  TMP = File.dirname(__FILE__) + File::SEPARATOR + 'tmp'
+
+  attr_reader :repo
+
+  def setup
+    FileUtils.remove_dir(TMP) if File.exist?(TMP)
+    Dir.mkdir(TMP)
+
+    path = TMP + File::SEPARATOR + 'test'
+    @repo = GitDS::Repo.create(path)
+
+    # add basic structure to repo
+    idx = @repo.index
+    idx.add( 'class a/instance a/prop a', 'aaaaaaaaaa' )
+    idx.add( 'class a/instance a/prop b', 'bbbbbbbbbb' )
+    idx.add( 'class a/instance b/prop a', 'AAAAAAAAAA' )
+    idx.add( 'class a/instance b/prop b', 'BBBBBBBBBB' )
+    idx.add( 'class b/instance a/prop a', '1111111111' )
+    idx.add( 'class b/instance a/prop b', '2222222222' )
+    idx.add( 'class c/instance a/prop a', 'zzzzzzzzzz' )
+    idx.add( 'class c/instance a/prop b', 'xxxxxxxxxx' )
+    idx.add( 'class c/instance a/class d/prop 1', '-_-_-_-_-_' )
+    idx.add( 'class c/instance a/class d/prop 2', '=+=+=+=+=+' )
+
+    idx.commit('initial import')
+    @repo.staging = nil
+  end
+
+  def teardown
+    FileUtils.remove_dir(TMP) if File.exist?(TMP)
+  end
+
+  def test_create
+    path = TMP + File::SEPARATOR + 'test_create'
+    repo = GitDS::Repo.create(path)
+
+    assert(File.exist?(path + File::SEPARATOR + '.git'), 
+           "Repo #{path} not created!") 
+    assert_equal(path, repo.top_level, 'Repo#top_level returned wrong value')
+
+    repo.exec_in_git_dir {
+      assert( File.exist?('.git'), 'Repo#exec_in_git_dir failed' )
+    }
+    # TODO: repo.exec_git_cmd()
+  end
+
+  def test_list
+    dir = 'class c/instance a/class d'
+    path, data = "#{dir}/prop 1", '-_-_-_-_-_'
+
+    # test include
+    assert( @repo.include?(dir), 'Repo#include? does not include path' )
+    assert( @repo.include?(path), 'Repo#include? does not include path' )
+
+    assert_nil( @repo.object_data(dir), 'blob data returned for path' )
+    assert_equal( data, @repo.path_to_object(path).data, 
+                  'Repo#path_to_object#data returned wrong data for blob' )
+    assert_equal( data, @repo.object_data(path), 
+                  'Repo#object_data returned wrong data for blob' )
+
+    # Test listing of tree contents
+    assert_equal( 3, @repo.tree_contents(@repo.tree).keys.count,
+                  'Repo#list returns wrong contents for root tree' )
+    assert_equal( 3, @repo.tree_contents(@repo.tree(@repo.root_sha)).keys.count,
+                  'Repo#list returns wrong contents for root_sha' )
+    assert_equal( ['class a', 'class b', 'class c'], @repo.list.keys.sort,
+                  'Repo#list returns wrong contents for root' )
+    assert_equal( ['instance a', 'instance b'], @repo.list('class a').keys.sort,
+                  'Repo#list returns wrong contents for "class a"' )
+
+    # Test listing of only Blobs or only Trees
+    assert_equal(0, @repo.list_blobs().count, 'List Blobs has wrong root count')
+    assert_equal(3, @repo.list_trees().count, 'List Trees has wrong root count')
+    assert_equal(2, @repo.list_blobs('class c/instance a').count, 
+                 'List Blobs has wrong count')
+    assert_equal(1, @repo.list_trees('class c/instance a').count, 
+                 'List Trees has wrong count')
+
+    # Test recursive raw-tree generation
+    output = @repo.raw_tree('class c')
+    assert_equal(1, output.split("\n").count, 'Incorrect count for raw_tree')
+    output = @repo.raw_tree('class c', true)
+    assert_equal(4, output.split("\n").count, 'Incorrect count for raw_tree')
+
+    # Make sure that '' gets us a root Tree object
+    output = @repo.raw_tree('')
+    assert_equal(3, output.split("\n").count, 'Incorrect count for raw_tree')
+    output = @repo.raw_tree('', true)
+    assert_equal(10, output.split("\n").count, 'Incorrect count for raw_tree')
+  end
+
+  def test_index
+    idx = @repo.index_new
+    assert_equal(GitDS::Index, idx.class, 'Repo#index_new returns wrong class')
+    idx = @repo.index
+    assert_equal(GitDS::StageIndex, idx.class, 'Repo#index returns wrong class')
+
+    assert( @repo.staging?(), 'Repo#staging returned FALSE' )
+
+    path, data = 'class c/instance a/prop b', 'XXXXXXXXXX'
+    @repo.stage { |idx|
+      idx.add( path, data )
+    }
+
+    assert_equal(data, @repo.object_data(path), 'Stage did not write data')
+
+    @repo.staging = nil
+    assert( (not @repo.staging?), 'Repo#staging returned TRUE' )
+
+    msg = 'this is a test'
+    @repo.stage_and_commit(msg) { |idx|
+      idx.add( path, data )
+    }
+
+    # ensure this doesn't screw up repo
+    output = @repo.raw_tree('')
+    assert_equal(3, output.split("\n").count, 'Incorrect count for raw_tree')
+  end
+
+  def test_branch_and_tag
+    assert_equal(0, @repo.tags.count, 'Expected initial tag count of 0')
+    assert_equal('1_2_3_4_5_6_7_8_9_0_', 
+                 @repo.clean_tag('1!2@3#4$5%6^7&8*9(0)'),
+                 'clean_tag did not clean')
+
+    # Tag a commit
+    sha = @repo.commits.first.id
+    name = 'the tag is'
+    @repo.tag_object(name, sha)
+    assert_equal(1, @repo.tags.count, 'Tag did not get added')
+    assert_equal('the_tag_is', @repo.tags.first.name, 'Tag name did not match')
+    assert_equal(1, 
+                 @repo.tags.select{|t| t.name == @repo.clean_tag(name)}.count, 
+                 'Tag did not get added with right name')
+
+    assert_equal('0.0.0', @repo.last_branch_tag, 'invalid initial tag value')
+    assert_equal('0.0.1', @repo.next_branch_tag, 'next_branch_tag failed')
+
+    assert_equal(GitDS::Repo::DEFAULT_BRANCH, @repo.current_branch,
+                 'Current branch is not default branch')
+    assert_equal(GitDS::Repo::DEFAULT_BRANCH, @repo.branch.name,
+                 'Current branch is not default branch')
+
+    # create new branch
+    assert_equal(1, @repo.branches.count, '> 1 branches exist on init')
+    new_branch = @repo.create_branch( 'v01' )
+    assert_equal(2, @repo.branches.count, 'new branch not added')
+
+    # switch to new branch
+    @repo.set_branch(new_branch)
+    assert_equal(new_branch, @repo.current_branch, 'Curr branch != new branch')
+    assert_equal(new_branch, @repo.branch.name, 'Current branch != new branch')
+
+    # switch back
+    @repo.set_branch(GitDS::Repo::DEFAULT_BRANCH)
+    assert_equal(GitDS::Repo::DEFAULT_BRANCH, @repo.branch.name,
+                 'Current branch is not default branch')
+
+    # create new branch with auto-tag name of 0.0.2
+    v2 = @repo.create_branch
+    assert_equal('0.0.2', v2, 'New branch did not get assigned 0.0.2 name')
+    assert_equal(3, @repo.branches.count, 'new branch not added')
+
+    # switch to new branch and change data
+    @repo.set_branch(new_branch)
+    path, data = 'class c/instance a/prop b', '~~~~~~~~~~'
+    @repo.stage_and_commit('test commit for merge') { |idx|
+      idx.add( path, data )
+    }
+    assert_equal(data, @repo.object_data(path), 'Stage did not write data')
+
+    # test that staging index gets preserved
+    b_stage = @repo.staging
+    @repo.set_branch(GitDS::Repo::DEFAULT_BRANCH)
+    assert( (not @repo.staging?), 'Staging index not cleared on branch' )
+    @repo.set_branch(new_branch)
+    assert( (@repo.staging?), 'Staging index not restored on branch' )
+    assert_equal(b_stage, @repo.staging, 'Staging index not saved on branch')
+
+    # merge new branch to master
+    @repo.merge_branch
+    assert_equal(GitDS::Repo::DEFAULT_BRANCH, @repo.branch.name,
+                 'Current branch is not default branch')
+    assert_equal(data, @repo.object_data(path), 'Merge did not write data')
+  end
+
+  def test_index_mod_and_list
+    path, data = 'class e/prop_1', '.:.:.:.:.'
+
+    # list top-level should have 3 entries
+    assert_equal( 3, @repo.tree_contents(@repo.tree).keys.count,
+                  'Repo#list returns wrong contents for root tree' )
+
+    @repo.add( path, data )
+    assert_equal( data, @repo.object_data(path), 
+                  'Repo#object_data returned wrong data for blob' )
+
+    # list top-level should have 4 entries
+    assert_equal( 4, @repo.tree_contents(@repo.tree).keys.count,
+                  'Repo#list returns wrong contents for root tree' )
+
+    # Discard staging index
+    @repo.unstage
+
+    # list top-level should have 3 entries again
+    assert_equal( 3, @repo.tree_contents(@repo.tree).keys.count,
+                  'Repo#list returns wrong contents for root tree' )
+
+    @repo.add( path, data )
+    assert_equal( data, @repo.object_data(path), 
+                  'Repo#object_data returned wrong data for blob' )
+
+    @repo.delete('class e/')
+    
+    # list top-level should have 3 entries again
+    assert_equal( 3, @repo.tree_contents(@repo.tree).keys.count,
+                  'Repo#list returns wrong contents for root tree' )
+    @repo.staging=nil
+
+    # TODO: modification while index is active.
+  end
+
+  def test_add_fs
+    path, data = 'test-fs', 'trtrtrtrt'
+    @repo.add(path, data, true)
+    assert_equal( 4, @repo.tree_contents(@repo.tree).keys.count,
+                  'Repo#list returns wrong contents for root tree' )
+
+    @repo.exec_in_git_dir {
+      assert( ::File.exist?(path), 'File not exist after repo-fs-add' )
+    }
+
+    @repo.unstage
+  end
+
+  def test_add_db
+    path, data = 'test-db', 'bdbdbdbdb'
+    @repo.add(path, data)
+    assert_equal( 4, @repo.tree_contents(@repo.tree).keys.count,
+                  'Repo#list returns wrong contents for root tree' )
+
+    @repo.exec_in_git_dir {
+      assert( (not ::File.exist? path), 'File exists after repo-db-add' )
+    }
+
+    @repo.unstage
+  end
+
+end
+

data/tests/ut_user_group_model.rb

@@ -0,0 +1,316 @@
+#!/usr/bin/env ruby
+# Copyright 2011 Thoughtgang <http://www.thoughtgang.org>
+# Unit test for Git-DS Model class API
+
+require 'test/unit'
+require 'fileutils'
+
+require 'git-ds/database'
+require 'git-ds/model'
+
+# =============================================================================
+# Test database model:
+#   user/                          : FsModelItemClass
+#   user/$NAME/                    : FsModelItem
+#   user/$NAME/id                  : Property
+#   user/$NAME/role/               : DbModelItemClass
+#   user/$NAME/role/$NAME/         : DbModelItem
+#   user/$NAME/role/$NAME/auth     : Property
+#            
+#   group/                         : FsModelItemClass
+#   group/$NAME/                   : FsModelItem
+#   group/$NAME/id                 : Property
+
+# ----------------------------------------------------------------------
+# User Role. This is an in-DB item.
+class UserRoleModelItem
+  include GitDS::DbModelItemObject
+  extend GitDS::DbModelItemClass
+
+  name 'role'
+
+  property(:auth, 127) { |p| p.to_s.to_i == p && p >= 0 && p < 1024 }
+
+  def auth
+    integer_property(:auth)
+  end
+
+  def auth=(val)
+    set_property(:auth, val)
+  end
+end
+
+# ----------------------------------------------------------------------
+class UserModelItem
+  include GitDS::FsModelItemObject
+  extend GitDS::FsModelItemClass
+
+  name 'user'
+
+  # properties
+  property(:id, 0) { |p| p.to_s.to_i == p }
+
+  def initialize(model, path)
+    super
+    @roles = GitDS::ModelItemList.new(UserRoleModelItem, model, path)
+  end
+
+  # Use :username entry in Hash as primary key
+  def self.ident_key
+    :username
+  end
+
+  # Override default fill method to set non-Property children
+  def self.fill(model, item_path, args)
+    super
+
+    # create user role
+    args[:roles].each do |role|
+      UserRoleModelItem.create_in_path(model, item_path, role)
+    end
+  end
+
+  alias :username :ident
+
+  def id
+    integer_property(:id)
+  end
+
+  def id=(val)
+    set_property(:id, val)
+  end
+
+  def roles
+    ensure_valid
+    @roles.keys
+  end
+
+  def role(name)
+    ensure_valid
+    @roles[name]
+  end
+
+  def add_role(ident, auth)
+    @roles.add(self, {:ident => ident, :auth => auth})
+  end
+
+end
+
+# ----------------------------------------------------------------------
+class GroupModelItem
+  include GitDS::FsModelItemObject
+  extend GitDS::FsModelItemClass
+
+  name 'group'
+
+  # properties
+  property(:id, 0) { |p| p.to_s.to_i == p }
+  link_property(:owner, UserModelItem)
+
+  def initialize(model, path)
+    super
+    @users = GitDS::ProxyItemList.new(UserModelItem, model, path)
+  end
+
+  # Use :name entry in Hash as primary key
+  # NOTE: This tests overriding of ident() instead of ident_key()
+  def self.ident(args)
+    args[:name]
+  end
+
+  alias :name :ident
+
+  def id
+    integer_property(:id)
+  end
+
+  def id=(val)
+    set_property(:id, val)
+  end
+
+  def owner
+    get_property(:owner)
+  end
+
+  def owner=(u)
+    set_property(:owner, u)
+  end
+
+  def users
+    ensure_valid
+    @users.keys
+  end
+
+  def user(name)
+    ensure_valid
+    @users[name]
+  end
+
+  def add_user(u)
+    @users.add(self, u, true)
+  end
+
+  def del_user(name)
+    @users.delete(name)
+  end
+end
+
+
+# =============================================================================
+class TC_GitUserGroupModelTest < Test::Unit::TestCase
+  TMP = File.dirname(__FILE__) + File::SEPARATOR + 'tmp'
+
+  attr_reader :db, :model
+
+  def setup
+    FileUtils.remove_dir(TMP) if File.exist?(TMP)
+    Dir.mkdir(TMP)
+    path = TMP + File::SEPARATOR + 'ug_model_test'
+    @db = GitDS::Database.new(path)
+    @model = GitDS::Model.new(@db)
+  end
+
+  def teardown
+    FileUtils.remove_dir(TMP) if File.exist?(TMP)
+  end
+
+  # ----------------------------------------------------------------------
+  def test_user_item
+    assert_equal(0, UserModelItem.list(@model.root).count, 'init # Users not 0')
+
+    args = { :username => 'admin', :id => 1, 
+             :roles => [ {:ident => 'sysadmin', :auth => 255},
+                         {:ident => 'operator'} ]
+           }
+    path = UserModelItem.create(@model.root, args)
+    assert_equal(1, UserModelItem.list(@model.root).count, 'User not created')
+
+    # User should exist on filesystem
+    @db.exec_in_git_dir {
+      assert(::File.exist?(path), 'UserModelItem.create failed')
+    }
+
+    assert( @model.exist?(path), 'User not created in object database' )
+    assert_equal(2, @model.list_children(path).count, 'User prop not created')
+    assert_equal(1, UserModelItem.list(@model.root).count, '>1 Users exist')
+
+    # Role should exist in database
+    role_path = path + File::SEPARATOR + 'role'
+    assert_equal(2, @model.list_children(role_path).count)
+
+    auth_path = role_path + File::SEPARATOR + 'sysadmin' + File::SEPARATOR + 
+                'auth'
+    assert( @model.exist?(auth_path) )
+
+    u = UserModelItem.new(@model, path)
+    assert_equal(args[:username], u.ident, 'User ident was not set')
+    assert_equal(args[:username], u.username, 'User username was not set')
+    assert_equal(args[:id], u.id, 'User property id was not set')
+    # try again after cache
+    assert_equal(args[:id], u.id, 'User property id was not cached')
+    assert_equal(args[:id], u.property_cache[:id], 'Cached property is wrong')
+
+    u.id = 5
+    assert_equal(5, u.id, 'User property id was not changed')
+    assert_equal(5, u.property_cache[:id], 'User property id was not changed')
+
+    # Verify that role accessor works
+    assert_equal(2, u.roles.count, 'Incorrect number of User roles')
+    assert_equal(['operator', 'sysadmin'], u.roles, 'Incorrect User roles')
+    assert_equal('operator', u.role('operator').ident, 'Incorrect role ident')
+    assert_equal(255, u.role('sysadmin').auth, 'Incorrect role auth')
+
+    u.role('operator').auth = 6
+    assert_equal(6, u.role('operator').auth, 'Role auth did not get set')
+
+    u.add_role('sucker', 7)
+    assert_equal(3, u.roles.count, 'User role did not get added')
+    assert_equal(['operator', 'sucker', 'sysadmin'], u.roles, 
+                 'Incorrect User roles after add')
+    assert_equal(7, u.role('sucker').auth, 'Role auth did not get set on add')
+
+    u.role('sucker').delete
+    assert_equal(2, u.roles.count, 'User role did not get deleted')
+    assert_equal(['operator', 'sysadmin'], u.roles, 'Incorrect User roles')
+
+    u.delete
+    assert( (not @model.exist? path) )
+    assert_equal(0, UserModelItem.list(@model.root).count, '>0 Users exist')
+
+    assert_raises(GitDS::InvalidModelItemError, 'Deleted item still usable') {
+      u.id
+    }
+    assert_raises(GitDS::InvalidModelItemError, 'Deleted item still usable') {
+      u.username
+    }
+    assert_raises(GitDS::InvalidModelItemError, 'Deleted item still usable') {
+      u.delete
+    }
+  end
+
+  # ----------------------------------------------------------------------
+  def test_group
+    assert_equal(0, GroupModelItem.list(@model.root).count, 'init # Groups > 0')
+
+    args = { :name => 'staff', :id => 1000 }
+    path = GroupModelItem.create(@model.root, args)
+    assert_equal(1, GroupModelItem.list(@model.root).count, 'Group not created')
+
+    # Group should exist on filesystem
+    @db.exec_in_git_dir {
+      assert(::File.exist?(path), 'GroupModelItem.create failed')
+    }
+
+    assert( @model.exist?(path), 'Group not created in object database' )
+    assert_equal(1, @model.list_children(path).count, 'Group prop not created')
+    assert_equal(1, GroupModelItem.list(@model.root).count, '>1 Groups exist')
+
+    g = GroupModelItem.new(@model, path)
+
+    assert_equal(0, g.users.count, 'User count > 0 in new group')
+
+    user_defs = [
+      { :username => 'admin', :id => 1, 
+        :roles => [{:ident => 'sysadmin', :auth => 255}, {:ident => 'operator'}]
+      },
+      { :username => 'bob', :id => 2, 
+        :roles => [{:ident => 'sysadmin', :auth => 1}, {:ident => 'operator'}]
+      },
+      { :username => 'bill', :id => 3, 
+        :roles => [{:ident => 'sysadmin', :auth => 127}, {:ident => 'operator'}]
+      },
+      { :username => 'jane', :id => 4, 
+        :roles => [{:ident => 'sysadmin', :auth => 15}, {:ident => 'operator'}]
+      }
+    ]
+    user_defs.each do |u| 
+      u[:path] = UserModelItem.create(@model.root, u)
+      u[:obj] = UserModelItem.new(@model, u[:path])
+      g.add_user(u[:obj])
+    end
+
+    assert_equal(user_defs.count, g.users.count, 'Bad User count new group')
+
+    assert_equal(user_defs.inject([]){ |arr, u| arr << u[:username] }.sort,
+                 g.users, 'Group user list does not match')
+
+    g.del_user('jane')
+    assert_equal(user_defs.count - 1, g.users.count, 'User not deleted!')
+
+    # cleanup
+    user_defs.each { |u| u[:obj].delete }
+
+    g.delete
+    assert( (not @model.exist? path) )
+    assert_equal(0, GroupModelItem.list(@model.root).count, '>0 Groups exist')
+
+    assert_raises(GitDS::InvalidModelItemError, 'Deleted item still usable') {
+      g.id
+    }
+    assert_raises(GitDS::InvalidModelItemError, 'Deleted item still usable') {
+      g.delete
+    }
+  end
+
+end
+