rally_workspace_utils 0.0.1

data/Manifest.txt

@@ -0,0 +1,17 @@
+Manifest.txt
+README.txt
+Rakefile
+setup.rb
+bin/translate_workspace
+bin/copy_workspace
+lib/translate/copy.rb
+lib/translate/version.rb
+lib/translate/translate.rb
+lib/translate/translation_audit.rb
+lib/translate/copy/rest_object.rb
+lib/translate/copy/story_copy.rb
+lib/translate/copy/test_case_result_copy.rb
+lib/translate/copy/defect_copy.rb
+lib/translate/copy/object_copy.rb
+lib/translate/copy/test_case_copy.rb
+lib/rally_workspace_utils.rb

data/README.txt

@@ -0,0 +1,3 @@
+README for rally_workspace_utils
+================================
+

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'translate', 'version')
+
+AUTHOR = "bcotton"  # can also be an array of Authors
+EMAIL = "bcotton@rallydev.com"
+DESCRIPTION = "A utility to translate a UseCase workspace to a UserStory workspace"
+GEM_NAME = "rally_workspace_utils" # what ppl will type to install your gem
+RUBYFORGE_PROJECT = "rally-rest-api" # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+RELEASE_TYPES = %w( gem ) # can use: gem, tar, zip
+
+
+NAME = "rally_workspace_utils"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (Translate::VERSION::STRING + (REV ? ".#{REV}" : ""))
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "translate documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/*_test.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+
+  p.extra_deps = []
+  p.extra_deps << ["rally_rest_api", ">= 0.6.2"]
+  p.extra_deps << ["activesupport"]
+
+  
+  # == Optional
+  #p.changes        - A description of the release's latest changes.
+  #p.extra_deps     - An array of rubygem dependencies.
+  #p.spec_extras    - A hash of extra values to set in the gemspec.
+end
+          

data/bin/copy_workspace

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+

data/bin/translate_workspace

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'getoptlong'
+require 'logger'
+require 'rubygems'
+require 'rally_rest_api'
+
+require 'rally_workspace_utils'
+
+opts = GetoptLong.new(
+                      ["--base_url", "-b", GetoptLong::REQUIRED_ARGUMENT],
+                      ["--debug", "-d", GetoptLong::NO_ARGUMENT],
+                      ["--from_workspace", "-f", GetoptLong::REQUIRED_ARGUMENT],
+                      ["--to_workspace", "-t", GetoptLong::REQUIRED_ARGUMENT],
+                      ["--username", "-u", GetoptLong::REQUIRED_ARGUMENT],
+                      ["--password", "-p", GetoptLong::REQUIRED_ARGUMENT],
+                      ["--audit", "-a", GetoptLong::NO_ARGUMENT],
+                      ["--logfile", "-l", GetoptLong::REQUIRED_ARGUMENT],
+                      ["--help", "-h", GetoptLong::NO_ARGUMENT]
+)
+
+def usage
+  puts "usage: #{$0}"
+  puts "   -b|--base_url <url> The base URL of the system to translate. Defaults to 'https://rally1.rallydev.com/slm'"
+  puts "   -d|--debug Turn debugging on"
+  puts "   -f|--from_workspace <workspace name> The name of the workspace we are translating. Must be a UseCase style workspace"
+  puts "   -t|--to_workspace   <workspace name> The name of the workspace we are tranlating to. Must be a UserStory style workspace"
+  puts "   -a|--audit   Compare the old workspace against the new one"
+  puts "   -l|--logfile <filename> A file the logger should log to. Defaults to STDOUT"
+  puts "   -u|--username <username> The rally login of a subscription administrator."
+  puts "   -p|--password <password> The password of the above user."
+  puts "   -h|--help This help"
+  exit
+end
+
+args = {:base_url => "https://rally1.rallydev.com/slm"}
+
+debug = false
+logfile = STDOUT
+
+opts.each do |opt, arg|
+  case opt
+  when "--base_url"
+    args[:base_url] = arg
+  when "--from_workspace"
+    puts "arg = #{arg}"
+    args[:from_workspace] = arg
+  when "--to_workspace"
+    args[:to_workspace] = arg
+  when "--username"
+    args[:username] = arg
+  when "--password"
+    args[:password] = arg
+  when "--debug"
+    debug = true
+    RestBuilder::DEBUG = true
+  when "--logfile"
+    logfile = arg
+  when "--help" 
+    usage
+  else
+    puts "Unknown argument #{opt}"
+    usage
+  end
+end
+
+
+
+[:base_url, :to_workspace, :from_workspace, :username, :password].each do |arg|
+  unless args[arg]
+    puts "#{arg} is a required argument"
+    usage 
+  end
+end  
+
+logger = Logger.new(logfile)
+if debug
+  logger.level = Logger::DEBUG
+else
+  logger.level = Logger::INFO
+end
+args[:logger] = logger
+
+translate = Translate.new(args)
+puts translate.inspect
+translate.run
+
+

data/lib/rally_workspace_utils.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/translate/translate'
+

data/lib/translate/copy/defect_copy.rb

@@ -0,0 +1,75 @@
+class DefectCopy < ObjectCopy
+
+  def shallow_copy(object, new_workspace)
+    values = super
+    values.delete(:submitted_by) unless user_exists? @object.submitted_by
+    values
+  end
+  
+  def tangle(new_workspace)
+    values = {}
+    new_defect = fetch_object(:defect, @object.oid, new_workspace)
+
+    # If the original defect is in a different project from the stories' card,
+    # then create a new user story, as the parent of this new user story, and make
+    # the requirement on the defect this new story
+    if @object.requirement != nil && @object.requirement.cards != nil && # The defect has a requirement, that is scheduled
+	@object.project != nil &&                                           # The defect in not in the parent project
+	@object.requirement.cards.first.project != @object.project         # The card in in a different project from the defect
+
+      story_name = @object.requirement.name
+      new_requirement = fetch_object(:artifact, @object.requirement.oid, new_workspace)
+      if new_requirement.parent && new_requirement.parent.project.nil?
+	parent_story = new_requirement.parent
+      else
+	parent_story = new_workspace.rally_rest.create(:hierarchical_requirement, 
+						       :workspace => new_workspace,
+						       :name => "Parent story for UserStory '#{story_name}' to hold defects in project #{@object.project.name}")
+	@object.rally_rest.logger.info "During the tangle of defect '#{@object.name}' we needed to create a new UserStory and make it the parent of this defect's requirement. This is because the original Story was scheduled into a project that was diffetent than the project this defect is in."
+      end
+      new_requirement.update(:parent => parent_story)
+      values[:requirement] = parent_story
+    else
+      
+      # if the old defect has a test case
+      unless @object.test_case.nil?
+	# get the new test_case
+	new_test_case = fetch_object(:test_case, @object.test_case.oid, new_workspace)
+	# update
+	values[:test_case] = new_test_case
+
+	# if the new defect is in the Parent Project and 
+	# the its related test_case is not in the same project as the defect,
+	# then put the defect in the same project as the test_case
+	if new_defect.project.nil? && new_defect.project != new_test_case.project
+	  values[:project] = new_test_case.project
+	end
+      end
+
+      # if the old defect has a requirement
+      if !@object.requirement.nil? && @object.requirement.type == "Story"
+	# get the requiement, copied from this defect's requirement
+	new_story = fetch_object(:artifact, @object.requirement.oid, new_workspace)
+	# update the new defect
+	values[:requirement] = new_story
+
+	# if the new defect is in the Parent Project and 
+	# the new requirement is not in the same project as the defect,
+	# then put the defect in the same project as the requirement
+	if new_defect.project.nil? && new_defect.project != new_story.project
+	  values[:project] = new_story.project
+	end
+      end
+    end
+
+    # tangle the duplicate defects
+    unless @object.duplicates.nil?
+      dups = []
+      @object.duplicates.values.each do |dup|
+	dups << fetch_object(:defect, dup.oid, new_workspace)
+      end
+      values[:duplicates] = dups
+    end
+    new_defect.update(values) unless values.length == 0
+  end
+end

data/lib/translate/copy/object_copy.rb

@@ -0,0 +1,97 @@
+require 'pp'
+
+class ObjectCopy
+  def initialize(object)
+    @object = object
+  end
+
+  def copy(new_workspace, additional_values = {})
+    values = shallow_copy(@object, new_workspace)
+    values.merge! additional_values
+
+    values[:workspace] = new_workspace
+    values[:project] = find_project_in_new_workspace(new_workspace)
+    
+    @new_object = create_object(new_workspace.rally_rest, values)
+    remember @object, @new_object
+    copy_children(new_workspace)
+
+    @new_object
+  end
+
+  def remember old, new
+    $TRANSLATED ||= {}
+    $TRANSLATED[old.oid] = new.oid
+  end
+
+  def create_object(rally_rest, values)
+    rally_rest.create(@object.type_as_symbol, values)
+  end
+
+  def find_project_in_new_workspace(new_workspace)
+    # I'm assuming (after talking to nate) that if the project is nil, there there is more then one project in the 
+    # workspace. At least for single project workspaces that were migrated for project scoping, this is true.
+    if @object.project.nil?
+      return nil
+    else
+      fetch_project(@object.project.name, new_workspace)
+    end
+  end
+
+  def fetch_project(project_name, workspace)
+    @@cached_projects ||= {}
+    return @@cached_projects[project_name] if @@cached_projects.key? project_name
+    project = workspace.rally_rest.find(:project, :workspace => workspace) { equal :name, project_name }.first
+    @@cached_projects[project_name] = project
+  end
+
+  def shallow_copy(object, new_workspace)
+    keys_to_exclude = excluded_attributes(object)
+    values = object.elements.reject { |key, value| keys_to_exclude.include? key }
+    values.delete(:owner) unless user_exists? @object.owner
+
+    # Here we need to fix any deleted custom dropdown values that have been deleted
+    values.each do |attribute, value|
+      if @object.typedef.custom_dropdown_attributes.key? attribute
+	attrdef = @object.typedef.custom_dropdown_attributes[attribute]
+	unless attrdef.allowed_values.include? value
+	  values[attribute] = nil 
+	  puts "Deleteing #{attribute} = #{value} from @{object.name} because it no longer exists"
+	end
+      end
+    end
+
+    values
+  end
+
+  def excluded_attributes(object)
+    object.typedef.reference_attributes(true).keys
+  end
+
+  def copy_children(new_workspace)
+  end
+
+  def user_exists?(username)
+    @@cached_users ||= {}
+
+    return true if username.nil?
+    return @@cached_users[username] if @@cached_users.key? username
+
+    result = @object.rally_rest.find(:user) { equal :login_name, username }
+    if result.total_result_count > 0
+      @@cached_users[username] = true
+    else
+      @@cached_users[username] = false
+    end
+  end
+
+  def fetch_object(type, oid, workspace)
+    @@cached_objects ||= {}
+    new_oid = $TRANSLATED[oid]
+    return @@cached_objects[new_oid] if @@cached_objects.key? oid
+    
+    object = @object.rally_rest.find(type, :workspace => workspace) { equal :object_i_d, new_oid }.first
+    @@cached_objects[new_oid] = object
+  end
+end
+

data/lib/translate/copy/rest_object.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rally_rest_api'
+
+class RestObject
+  def copy(new_workspace, additional_values = {})
+    copy_class.new(self).copy(new_workspace, additional_values)
+  end
+
+  def tangle(new_workspace)
+    copy_class.new(self).tangle(new_workspace)
+  end
+
+  def excepted_attributes
+    [:object_id, :creation_date, :formatted_id, :owner] + self.typedef.reference_attributes(true).keys + self.typedef.custom_dropdown_attributes.keys
+  end
+
+  def copy_class
+    case self.type_as_symbol
+    when :card : CardCopy
+    when :story : StoryCopy
+    when :test_case : TestCaseCopy
+    when :defect : DefectCopy
+    when :test_case_result : TestCaseResultCopy
+    else
+      ObjectCopy
+    end
+  end
+end
+

data/lib/translate/copy/story_copy.rb

@@ -0,0 +1,44 @@
+class StoryCopy < ObjectCopy
+  def shallow_copy(object, new_workspace)
+    values = super
+    
+    unless object.cards.nil?
+      values[:rank] = object.cards.first.rank 
+      values[:schedule_state] = object.cards.first.state 
+
+      unless object.cards.first.iteration.nil?
+	iteration_name = object.cards.first.iteration.name
+	iteration = fetch_object(:iteration, object.cards.first.iteration.oid, new_workspace)
+	values[:iteration] = iteration if iteration
+      end
+
+      unless object.cards.first.release.nil?
+	release_name = object.cards.first.release.name
+	release = fetch_object(:release, object.cards.first.release.oid, new_workspace)
+	values[:release] = release if release
+      end
+
+    end
+    values
+  end
+
+  def find_project_in_new_workspace(new_workspace)
+    if @object.cards.nil?
+      return super
+    elsif @object.cards.first.project.nil?
+      return super 
+    else
+      fetch_project(@object.cards.first.project.name, new_workspace)
+    end
+  end
+
+  def create_object(rally_rest, values)
+    rally_rest.create(:hierarchical_requirement, values)
+  end
+
+   def copy_children(new_workspace)
+     @object.cards.first.tasks.values.flatten.each do |task|
+       task.copy(new_workspace, :work_product => @new_object)
+     end if !@object.cards.nil? && !@object.cards.first.tasks.nil?
+   end
+end

data/lib/translate/copy/test_case_copy.rb

@@ -0,0 +1,53 @@
+
+class TestCaseCopy < ObjectCopy
+  def copy_children(new_workspace)
+    @object.results.each do |result|
+      result.copy(new_workspace, :test_case => @new_object)
+    end unless @object.results.nil?
+
+    @object.steps.each do |step|
+      step.copy(new_workspace, :test_case => @new_object)
+    end unless @object.steps.nil?
+  end
+
+  def tangle(new_workspace)
+    
+    values = {}
+    if  !@object.work_product.nil? && @object.work_product.type == "Story"
+      # if the old test case has a work product
+      new_test_case = fetch_object(:test_case, @object.oid, new_workspace)
+      # get the new test case copied from this testcase
+      new_work_product = fetch_object(:artifact, @object.work_product.oid, new_workspace)
+
+      values[:work_product] = new_work_product
+
+
+      
+      # If the original test_case is in a different project from the stories' card,
+      # then create a new user story, as the parent of this new user story, and make
+      # the work_product on the test case the new parent
+      if @object.work_product != nil && @object.work_product.cards != nil &&  # The TC has a work_product, that is scheduled
+	  @object.project != nil &&                                           # The TC in not in the parent project
+      	  @object.work_product.cards.first.project != @object.project         # The card in in a different project from the test_case
+
+	story_name = @object.work_product.name
+	parent_story = new_workspace.rally_rest.create(:hierarchical_requirement, 
+						       :workspace => new_workspace,
+						       :project => nil,
+						       :name => "Parent story for #{story_name} to hold test cases in project #{@object.project.name}")
+	new_work_product.update(:parent => parent_story)
+	values[:work_product] = parent_story
+
+      # if the new test case is in the Parent Project and 
+      # the new work_product is not in the same project as the test case, 
+      # then put the test case in the same project as the work_product
+      elsif new_test_case.project.nil? && new_test_case.project != new_work_product.project
+	values[:project] = new_work_product.project
+      end
+      
+      
+      # update the new test case
+      new_test_case.update(values) unless values.length == 0
+    end
+  end
+end

data/lib/translate/copy/test_case_result_copy.rb

@@ -0,0 +1,7 @@
+class TestCaseResultCopy < ObjectCopy
+  def shallow_copy(object, new_workspace)
+    values = super
+    values.delete(:tester) unless user_exists? @object.tester
+    values
+  end
+end

data/lib/translate/copy.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'rally_rest_api'
+
+require 'translate/copy/rest_object'
+require 'translate/copy/object_copy'
+require 'translate/copy/defect_copy'
+require 'translate/copy/story_copy'
+require 'translate/copy/test_case_copy'
+require 'translate/copy/test_case_result_copy'

data/lib/translate/translate.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/copy'
+require File.dirname(__FILE__) + '/translation_audit'
+
+class Translate
+  include TranslationAudit
+
+  def initialize(args)
+    @base_url = args[:base_url]
+    @username = args[:username]
+    @password = args[:password]
+    @from_workspace_name = args[:from_workspace]
+    @to_workspace_name = args[:to_workspace]
+    @logger = args[:logger] if args[:logger]
+    $TRANSLATED ||= {}
+  end
+
+  def run
+    @slm = RallyRestAPI.new(:base_url => @base_url, :username => @username, :password => @password, :logger => @logger)
+
+    @from_workspace = @slm.user.subscription.workspaces.values.flatten.find { |w| w.name == @from_workspace_name } 
+    @to_workspace = @slm.user.subscription.workspaces.values.flatten.find { |w| w.name == @to_workspace_name } 
+
+    raise "No such workspace #{@from_workspace_name}" unless @from_workspace
+    raise "No such workspace #{@to_workspace_name}" unless @to_workspace
+
+
+    if File::exists? "TRANSLATED"
+      File.open("TRANSLATED", "r") do |f|
+	$TRANSLATED = Marshal.load(f)
+      end
+
+      if $TRANSLATED[:from] != @from_workspace.oid && $TRANSLATED[:to] != @to_workspace.oid
+	$TRANSLATED = {}
+	$TRANSLATED[:from] = @from_workspace.oid
+	$TRANSLATED[:to] = @to_workspace.oid
+      end
+    end
+
+    # now do the copy
+    [:iteration, :release, :story, :defect, :test_case].each do |type|
+      @slm.find_all(type, :workspace => @from_workspace).each do |o|
+	@logger.info "Copying #{o.type} -- #{o.name}"
+	o.copy(@to_workspace)
+      end
+    end unless $TRANSLATED[:copy]
+    # mark these workspaces as copied
+    $TRANSLATED[:copy] = true
+    # dump the oids to disk
+    dump_oids
+
+    # Now tangle the objects
+    [:test_case, :defect].each do |type|
+      @slm.find_all(type, :workspace => @from_workspace).each do |o|
+	@logger.info "Tangle #{o.type} -- #{o.name}"
+	o.tangle(@to_workspace)
+      end
+    end unless $TRANSLATED[:tangle]
+    
+    $TRANSLATED[:tangle] = true
+    dump_oids
+  end
+
+  def dump_oids
+    File.open("TRANSLATED", "w+") do |f|
+      Marshal.dump($TRANSLATED, f)
+    end
+  end
+
+end

data/lib/translate/translation_audit.rb

@@ -0,0 +1,76 @@
+
+module TranslationAudit
+  def audit
+    all_copied_fields_should_match_for :iteration  
+    all_copied_fields_should_match_for :release
+    all_copied_fields_should_match_for :defect
+    all_copied_fields_should_match_for :defect, [:last_run]
+    all_copied_fields_should_match_for :test_case_result, [:test_case]
+    compare_each :test_case_result do |old, new|
+      if old.test_case.name != new.test_case.name
+	puts "#{old.type} --  #{old.name} is different"
+      end
+    end      
+
+    all_copied_fields_should_match_for :test_case_step, [:test_case]
+    compare_each :test_case_step do |old, new|
+      if old.test_case.name != new.test_case.name
+	puts "#{old.type} --  #{old.name} is different"
+      end
+    end      
+    all_copied_fields_should_match_for :task, [:work_product]
+    compare_each :task do |old, new|
+      if old.card.work_product.name != new.work_product.name
+	puts "#{old.type} --  #{old.name} is different"
+      end
+    end
+
+    compare_each :defect do |old, new|
+      if !old.requirement.nil? && old.requirement.type == "Story"
+	if new.requirement.children
+	  old.requirement.name.should == new.requirement.children.values.first.name
+	else
+	  old.requirement.name.should == new.requirement.name
+	end
+      end
+    end
+
+    compare_each :test_case do |old, new|
+      if !old.work_product.nil? && old.work_product.type == "Story"
+	if new.work_product.children
+	  old.work_product.name.should == new.work_product.children.values.first.name
+	else
+	  old.work_product.name.should == new.work_product.name
+	end
+
+      end
+    end
+  end
+
+  def compare_each(type)
+    @slm.find_all(type, :workspace => @from_workspace).each do |old_object|
+      new_object = @slm.find(type, :workspace => @to_workspace) { equal :object_i_d, $TRANSLATED[old_object.oid] }.first
+      if new_object.nil?
+	puts "Cound not find an copy for object #{old_object.type} -- #{old_object.name} -- #{old_object.oid}"
+	next
+      end
+      yield old_object, new_object
+    end
+  end
+
+  def all_copied_fields_should_match_for(type, additional_exceptions = [])
+    compare_each(type) do |old_object, new_object| 
+      excepted_attributes = old_object.excepted_attributes + additional_exceptions
+      old_hash = old_object.elements.reject { |k, v| excepted_attributes.include?(k) }
+      new_hash = {}
+      old_hash.each_key do |k|
+	new_hash[k] = new_object.elements[k]
+      end
+      diff = old_hash.diff(new_hash)
+      if diff.length > 0
+	puts "#{old_hash.inspect} shoud == #{new_hash.inspect}"
+	puts "all_copied_fields_should_match_for #{type} diff = #{diff.inspect}"
+      end
+    end
+  end
+end

data/lib/translate/version.rb

@@ -0,0 +1,9 @@
+module Translate #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end