perforce2svn 0.7.0

data/spec/integration/perforce/p4_depot_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helpers'
+require 'perforce2svn/perforce/p4_depot'
+
+module Perforce2Svn::Perforce
+  describe P4Depot do
+    it "should be able to connect to the Perforce server" do
+      attempting {
+        P4Depot.instance.connect!
+      }.should_not raise_error
+    end
+
+    it "should be able to retrieve the latest revision" do
+      P4Depot.instance.latest_revision.should >= 8000
+    end
+  end
+end

data/spec/integration/perforce/perforce_file.yml

@@ -0,0 +1,4 @@
+revision: 2
+author: 'james.kirk'
+match: 'package com.bigfishgames.faunasphere'
+path: '//depot/gamecommunity/thinglefin/trunk/services/src/main/java/com/bigfishgames/faunasphere/simulation/world/FaunaWorld.java'

data/spec/integration/perforce/perforce_file_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helpers'
+require 'perforce2svn/perforce/perforce_file'
+require 'yaml'
+
+module Perforce2Svn::Perforce
+  describe PerforceFile do
+    before :each do
+      config_file = File.join(File.dirname(__FILE__), 'perforce_file.yml')
+      @config = YAML::load_file(config_file)
+      @file = PerforceFile.new(@config['revision'], @config['path'], nil, 'text', 'add')
+    end
+
+    it "should be able to retrieve file contents." do
+      @file.contents.should match(Regexp.compile(@config['match']))
+    end
+
+    it "should locate the symlink"
+  end
+end

data/spec/integration/subversion/svn_repo_spec.rb

@@ -0,0 +1,93 @@
+require 'perforce2svn/errors'
+require 'perforce2svn/subversion/svn_repo'
+require 'spec_helpers'
+require 'fileutils'
+
+module Perforce2Svn::Subversion
+  describe SvnRepo do
+    include CommitHelper
+
+    before :each do
+      @repo = SvnRepo.new('REPO')
+    end
+    
+    after :each do
+      @repo.delete!
+    end
+
+    it 'should create a new repository upon initialization' do
+      File.exists?(@repo.repository_path).should be(true)
+      File.exists?(File.join(@repo.repository_path, 'hooks')).should be(true)
+    end
+
+    it 'should fail to create a transaction when a block is not given' do
+      attempting { 
+        @repo.transaction('me', Time.now, 'log') 
+      }.should raise_error(Perforce2Svn::SvnTransactionError, /block-scoped/)
+    end
+
+    it "should be able to retrieve the file contents from a path" do
+      write('/a', "this is some text")
+      @repo.pull_contents('/a').should eql("this is some text")
+    end
+
+    it "should fail when the file contents don't exist" do
+      attempting {
+        @repo.pull_contents('/a')
+      }.should raise_error(Svn::Error::FsNotFound, /revision 0/)
+    end
+
+    it "should fail when a file exists but not at a given revision" do
+      write('/a', 'content')
+      attempting {
+        @repo.pull_contents('/a', 10)
+      }.should raise_error(Svn::Error::FsNoSuchRevision, /10/)
+    end
+
+    it "should be able to determine when a path doesn't exist" do
+      @repo.exists?('/a').should be_false
+    end
+
+    it "should be able to determine when a path exists" do
+      write('/a', 'contents')
+      @repo.exists?('/a').should be_true
+    end
+
+    it "should be able to retrieve the commit log" do
+      write('/a', 'contents')
+      commit = @repo.commit_log(1)
+      commit.author.should eql('gabe')
+    end
+
+    it "should be fail to retrieve the commit log on a bad revision" do
+      attempting {
+        @repo.commit_log(10)
+      }.should raise_error(Svn::Error::FsNoSuchRevision, /10/)
+    end
+
+    it "should be able to retrieve a property" do
+      write('/a', 'contents', true)
+      @repo.prop_get('/a', 'svn:mime-type', 1).should eql('application/octet-stream')
+    end
+
+    it "should be able to list child directories" do
+      write('/a', 'contents')
+      write('/b', 'contents')
+      @repo.children('/').should eql(['a', 'b'])
+    end
+
+    it "should not retrieve properties on non-existent paths" do
+      write('/a', 'contents')
+      attempting {
+        @repo.prop_get('/b', Svn::Core::PROP_REVISION_LOG)
+      }.should raise_error(Svn::Error::FsNotFound, /\/b/)
+    end
+
+    it "should fail to retrieve properties on a bad revision" do
+      write('/a', 'contents')
+      attempting {
+        @repo.prop_get('/a', Svn::Core::PROP_REVISION_AUTHOR, 5)
+      }.should raise_error(Svn::Error::FsNoSuchRevision, /5/)
+    end
+  end
+end

data/spec/integration/subversion/svn_transaction_spec.rb

@@ -0,0 +1,112 @@
+require 'perforce2svn/subversion/svn_repo'
+require 'spec_helpers'
+require 'stringio'
+
+module Perforce2Svn::Subversion
+  describe SvnTransaction do
+    include CommitHelper
+
+    before :each do
+      @repo = SvnRepo.new('REPO')
+    end
+
+    after :each do
+      @repo.delete!
+    end
+
+    it "should be able to commit a single change" do
+      write('/a.txt', "this is some text\nthat\goes here")
+      @repo.pull_contents('/a.txt').should eql("this is some text\nthat\goes here")
+    end
+
+    it "should be able to retrieve the updated file contents" do
+      write("/a.txt", "first commit")
+      write("/a.txt", 'second commit')
+      @repo.pull_contents('/a.txt').should eql('second commit')
+    end
+
+    it "should be able to delete a file" do
+      write('/a', 'conent')
+      delete('/a')
+      attempting { 
+        @repo.pull_contents('/a') 
+      }.should raise_error
+    end
+
+    it "can create multiple directories" do
+      @repo.exists?('/a/b/c').should be(false)
+
+      @repo.transaction('g', Time.new, 'l') do |txn|
+        txn.exists?('/a/b/c').should be(false)
+        txn.mkdir('/a/b/c')
+      end
+
+      @repo.exists?('/a/b/c').should be(true)
+    end
+
+    it "can delete all parent directories" do
+      write('/a/b/c/d.txt', 'some text')
+      write('/a/b.txt', 'other text')
+      delete('/a/b/c/d.txt')
+
+      @repo.exists?('/a/b/c').should be(false)
+    end
+
+    it "will write binary mime types correctly" do
+      jpg = read_in('spec/integration/madmen_icon_bigger.jpg', 'rb')
+      write('/a.jpg', jpg, true)
+
+      @repo.pull_contents('/a.jpg').should eql(jpg)
+      @repo.prop_get('/a.jpg', 'svn:mime-type').should eql('application/octet-stream')
+    end
+
+    it "will make sure that big files are retained correctly" do
+      hamlet = read_in('spec/integration/hamlet.txt')
+      write('/hamlet.txt', hamlet)
+
+      @repo.pull_contents('/hamlet.txt').should eql(hamlet)
+    end
+
+    it "will handle symlinks correctly" do
+      write("/src.txt", "some content")
+      symlink('./src.txt', '/b.txt')
+
+      @repo.pull_contents('/b.txt').should eql('link ./src.txt')
+      @repo.prop_get('/b.txt', 'svn:special').should eql('*')
+    end
+
+    it "will return the most recent revision number on commit" do
+      write('/a.txt', 'content').should eql(1)
+    end
+
+    it "will be able to find if a directory has children" do
+      write('/a/b.txt', 'content')
+      write('/a/c.txt', 'content')
+      @repo.transaction('gabe', Time.now, 'r') do |txn|
+        txn.has_children?('/a').should be(true)
+      end
+    end
+
+    it "will be able to copy paths" do
+      write('/a.txt', 'content')
+      @repo.transaction('gabe', Time.now, 'r') do |txn|
+        txn.copy('/a.txt', '/b.txt')
+      end
+
+      @repo.exists?('/a.txt').should be_true
+      @repo.exists?('/b.txt').should be_true
+      @repo.pull_contents('/b.txt').should eql('content')
+    end
+
+    it "will be able to move paths" do
+      write('/a.txt', 'content')
+      @repo.transaction('gabe', Time.now, 'r') do |txn|
+        txn.move('/a.txt', '/b.txt')
+      end
+
+      @repo.exists?('/a.txt').should be_false
+      @repo.exists?('/b.txt').should be_true
+      @repo.pull_contents('/b.txt').should eql('content')
+    end
+  end
+end

data/spec/perforce2svn/cli_spec.rb

@@ -0,0 +1,61 @@
+require 'perforce2svn/cli'
+require 'perforce2svn/errors'
+require 'spec_helpers'
+
+module Perforce2Svn
+  module CLIHelper
+    def parse(*args)
+      cli = CLI.new
+      args << '--repository'
+      args << 'here'
+      args << __FILE__
+      cli.parse!(args, true)
+    end
+  end
+
+  describe CLI do
+    include CLIHelper
+
+    it "should be able to parse the debug flag correctly" do
+      parse("--debug")[:debug].should be(true)
+    end
+
+    it "should be able to retrieve the repository path" do
+      parse('-r', 'some/path')[:repository].should eql('here')
+    end
+
+    it "should be able to parse the live path" do
+      parse('-l', '/')[:live_path].should eql('/')
+    end
+
+    it "should be able to skip updates" do
+      parse('--skip-commands')[:skip_commands].should be(true)
+    end
+
+    it "should be able to skip perforce" do
+      parse('--skip-perforce')[:skip_perforce].should be(true)
+    end
+
+    it "should be able to run the analysis only" do
+      parse('-a')[:analyze_only].should be(true)
+    end
+
+    describe "when validating the count format" do
+      it "should fail when the start revision is less than 1" do
+        attempting_to { 
+          parse('-c', '0:4') 
+        }.should raise_error(Choosy::ValidationError, /Minimum/)
+      end
+
+      it "should set -1 when given HEAD" do
+        parse('-c', '1:HEAD')[:changes].max.should eql(-1)
+      end
+
+      it "should fail when the end revision < 1" do
+        attempting_to {
+          parse('-c', '1:0')
+        }.should raise_error(Choosy::ValidationError, /Maximum/)
+      end
+    end
+  end
+end

data/spec/perforce2svn/mapping/analyzer_spec.rb

@@ -0,0 +1,41 @@
+require 'perforce2svn/logging'
+require 'perforce2svn/mapping/analyzer'
+require 'perforce2svn/mapping/commands'
+require 'ostruct'
+
+module Perforce2Svn::Mapping
+
+  module AnalyzerHelper
+    def analyzing(*commands)
+      a = Analyzer.new(File.dirname(__FILE__))
+      a.check(commands)
+    end
+
+    def updater(file = nil)
+      file ||= __FILE__
+      tok = OpenStruct.new
+      tok.line_number = 1
+      Update.new(tok, nil, file)
+    end
+  end
+
+  describe "Mapping analyzer" do
+    include AnalyzerHelper
+
+    it "should be able to test whether updated files exist" do
+      analyzing(updater).should be(true)
+    end
+
+    it "should fail when updated files don't exist" do
+      analyzing(updater("nowhere")).should be(false)
+    end
+
+    it "should be able to check multiple files" do
+      analyzing(updater("nowhere")).should be(false)
+    end
+
+    it "should be able to check when a file has a relative path" do
+      analyzing(updater(File.basename(__FILE__))).should be(true)
+    end
+  end
+end

data/spec/perforce2svn/mapping/branch_mapping_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helpers'
+require 'perforce2svn/mapping/branch_mapping'
+require 'ostruct'
+
+module Perforce2Svn::Mapping
+  module BranchMappingHelper
+    def map(p4, svn)
+      tok = OpenStruct.new
+      tok.line_number = 1
+      BranchMapping.new(tok, p4, svn)
+    end
+  end
+
+  describe "Branch Mappings" do
+    include BranchMappingHelper
+
+    it "should be able to determine when a path doesn't match" do
+      bm = map('//depot/path/', '/svn/path/here')
+      bm.matches_perforce_path?('//depot/not/here').should be(false)
+    end
+
+    it "should be able to determine when a path doesn't match" do
+      bm = map('//depot/path/', '/svn/path/here')        
+      bm.matches_perforce_path?('//depot/path/goes/here').should be(true)
+    end
+
+    it "should be able to format the dotted P4 path" do
+      bm = map('//depot/path/', '/svn/path/here')
+      bm.p4_dotted.should eql('//depot/path/...')
+    end
+
+    it "should be able to translate funky path characters correctly for subversion" do
+      bf = map("//p/", "/o/")
+      bf.to_svn_path("//p/%40/a").should eql("/o/@/a")
+      bf.to_svn_path("//p/%23/a").should eql("/o/#/a")
+      bf.to_svn_path("//p/%2a/a").should eql("/o/*/a")
+      bf.to_svn_path("//p/%25/a").should eql("/o/%/a") 
+    end
+  end
+end

data/spec/perforce2svn/mapping/lexer_spec.rb

@@ -0,0 +1,43 @@
+require 'perforce2svn/mapping/lexer'
+
+module Perforce2Svn
+  module Mapping
+
+    describe "Mapping lexer" do
+      it "should be able to parse a set of simple tokens in a line" do
+        lexer = Lexer.new(nil)
+        tok = lexer.tokenize('migrate this/that other/file')
+        tok.length.should eql(3)
+        tok[0].should eql('migrate')
+        tok[1].should eql('this/that')
+        tok[2].should eql('other/file')
+      end
+
+      it "should handle spaces in the path names" do
+        lexer = Lexer.new(nil)
+        tok = lexer.tokenize("migrate this/that\\ other/path will\\ be/something")
+        tok.length.should eql(3)
+        tok[0].should eql('migrate')
+        tok[1].should eql("this/that other/path")
+        tok[2].should eql("will be/something")
+      end
+
+      it "will delete multiple spaces" do
+        lexer = Lexer.new(nil)
+        tok = lexer.tokenize("     migrate     this/that     and/a\\ nother   ");
+        tok.length.should eql(3)
+        tok[0].should eql('migrate')
+        tok[1].should eql('this/that')
+        tok[2].should eql('and/a nother')
+      end
+
+      it "should leave off the comments at the end of lines" do
+        lexer = Lexer.new(nil)
+        tok = lexer.tokenize("this is a # comment string")
+        tok.length.should eql(3)
+        tok[0].should eql('this')
+        tok[2].should eql('a')
+      end
+    end
+  end
+end

data/spec/perforce2svn/mapping/parser_spec.rb

@@ -0,0 +1,140 @@
+require 'perforce2svn/mapping/parser'
+require 'stringio'
+
+module Perforce2Svn::Mapping
+  module ParserHelper
+    def parse(txt)
+      p = Parser.new
+      p.parse!(StringIO.new(txt), 'live')
+    end
+
+    def mappings(txt)
+      parse(txt)[:mappings]
+    end
+
+    def commands(txt)
+      parse(txt)[:commands]
+    end
+  end
+
+  describe Parser do
+    include ParserHelper
+
+    it "should fail when an unknown directive is found" do
+      parse(<<EOF
+# A comment
+not-directive arg
+EOF
+            )[:failed].should be(true)
+    end
+
+    it "should be able to parse 'update's" do
+      parse("update /some/path")[:failed].should be(false)
+    end
+
+    it "should be able to parse 'migrate'" do
+      c = mappings("migrate //depot/path /svn/path")
+      c[0].class.should eql(BranchMapping)
+      c[0].line_number.should eql(1)
+      c[0].svn_path.should eql('/svn/path/')
+    end
+
+    it "should fail to parse the 'update' command without a svn prefix" do
+      parse("update src/main/pom.xml")[:failed].should be(true)
+    end
+
+    it "should parse the 'update' command when an svn prefix is available" do
+      parse(<<EOF
+svn-prefix /some/path
+update src/main/pom.xml
+EOF
+                )[:failed].should be(false)
+    end
+
+    it "should parse the mapping file and return a list of migrations" do
+      m = mappings(<<EOF
+migrate //depot/path /trunk/project
+svn-prefix /trunk
+migrate //depot/partition another-project
+EOF
+                )
+
+      first = m[0]
+      first.line_number.should eql(1)
+      first.p4_path.should eql('//depot/path/')
+      first.svn_path.should eql('/trunk/project/')
+      
+      second = m[1]
+      second.line_number.should eql(3)
+      second.p4_path.should eql('//depot/partition/')
+      second.svn_path.should eql('/trunk/another-project/')
+    end
+
+    it "should be able to correctly parse updates" do
+      update = commands("update /src/dest.xml")[0]
+      update.class.should eql(Update)
+      update.line_number.should eql(1)
+      update.live_path.should eql('live/src/dest.xml')
+      update.svn_path.should eql('/src/dest.xml')
+    end
+
+    it "should be able to correctly parse delete" do
+      delete = commands("delete /src/another.java")[0]
+      delete.class.should eql(Delete)
+      delete.line_number.should eql(1)
+      delete.svn_path.should eql('/src/another.java')
+    end
+
+    it "should be able to correctly parse moves" do
+      move = commands("move /this/location.txt /to/here/location.txt")[0]
+      move.class.should eql(Move)
+      move.line_number.should eql(1)
+      move.svn_from.should eql('/this/location.txt')
+      move.svn_to.should eql('/to/here/location.txt')        
+    end
+
+    it "should be able to correctly parse copies" do
+      copy = commands("copy /src.txt /dest.txt")[0]
+      copy.class.should eql(Copy)
+      copy.line_number.should eql(1)
+      copy.svn_from.should eql('/src.txt')
+      copy.svn_to.should eql('/dest.txt')
+    end
+
+    it "should be able to insert the svn prefix when a live path is calculated" do
+      update = commands("svn-prefix /trunk/project\nupdate src/dest.xml")[0]
+      update.live_path.should eql('live/trunk/project/src/dest.xml')
+      update.svn_path.should eql('/trunk/project/src/dest.xml')
+    end
+
+    it "should fail when too many arguments are given to a command" do
+      parse('update /this/path /should/not/be')[:failed].should be(true)
+    end
+
+    it "should add the author to the context" do
+      parse('author An author')[:author].should eql('An author')
+    end
+
+    it "should add the message to the context" do
+      parse(<<EOF
+message this is a message that \
+        should span multiple lines \
+        and continue
+EOF
+           )[:message].should eql('this is a message that should span multiple lines and continue')
+    end
+
+    it "should be able to order the commands" do
+      cmds = commands(<<EOF
+update /src/dest.xml
+delete /src/another.java
+EOF
+                      )
+      
+      cmds[0].class.should eql(Update)
+      cmds[0].line_number.should eql(1)
+      cmds[1].class.should eql(Delete)
+      cmds[1].line_number.should eql(2)
+    end
+  end
+end