view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/swig/ruby/test/test_ra.rb  view on Meta::CPAN

    make_context(log) do |ctx0|
      config = {}
      path_props = {"my-prop" => "value"}
      callbacks = Svn::Ra::Callbacks.new(ctx0.auth_baton)
      Svn::Ra::Session.open(@repos_uri, config,callbacks) do |session|

        assert_equal(youngest_rev, session.latest_revnum)
        assert_equal(@repos_uri, session.repos_root)

        File.open(path, "w") {|f| f.print(src)}
        ctx0.add(path)
        info = ctx0.ci(@wc_path)
        rev1 = info.revision

        assert_equal(info.revision, session.dated_revision(info.date))
        content, props = session.file(file, info.revision)
        assert_equal(src, content)
        assert_equal([
                       Svn::Core::PROP_ENTRY_COMMITTED_DATE,
                       Svn::Core::PROP_ENTRY_UUID,
                       Svn::Core::PROP_ENTRY_LAST_AUTHOR,
                       Svn::Core::PROP_ENTRY_COMMITTED_REV,
                     ].sort,
                     props.keys.sort)
        entries, props = session.dir("", info.revision)
        assert_equal([file], entries.keys)
        assert(entries[file].file?)
        assert_equal([
                       Svn::Core::PROP_ENTRY_COMMITTED_DATE,
                       Svn::Core::PROP_ENTRY_UUID,
                       Svn::Core::PROP_ENTRY_LAST_AUTHOR,
                       Svn::Core::PROP_ENTRY_COMMITTED_REV,
                     ].sort,
                     props.keys.sort)

        entries, props = session.dir("", info.revision, Svn::Core::DIRENT_KIND)
        assert_equal(Svn::Core::NODE_FILE, entries[file].kind)
        entries, props = session.dir("", info.revision, 0)
        assert_equal(Svn::Core::NODE_UNKNOWN, entries[file].kind)

        make_context(log2) do |ctx|
          File.open(path, "w") {|f| f.print(src * 2)}
          path_props.each do |key, value|
            ctx.prop_set(key, value, path)
          end
          info = ctx.ci(@wc_path)
          rev2 = info.revision

          logs = []
          receiver = Proc.new do |changed_paths, revision, author, date, message|
            logs << [revision, message]
          end
          session.log([file], rev1, rev2, rev2 - rev1 + 1, &receiver)
          assert_equal([
                         [rev1, log],
                         [rev2, log2],
                       ].sort_by {|rev, log| rev},
                       logs.sort_by {|rev, log| rev})

          assert_equal(Svn::Core::NODE_FILE, session.check_path(file))
          assert_equal(Svn::Core::NODE_FILE, session.stat(file).kind)

          assert_equal({
                         rev1 => "/#{file}",
                         rev2 => "/#{file}",
                       },
                       session.locations(file, [rev1, rev2]))

          infos = []
          session.file_revs(file, rev1, rev2) do |_path, rev, rev_props, prop_diffs|
            hashed_prop_diffs = {}
            prop_diffs.each do |prop|
              hashed_prop_diffs[prop.name] = prop.value
            end
            infos << [rev, _path, hashed_prop_diffs]
          end
          assert_equal([
                         [rev1, "/#{file}", {}],
                         [rev2, "/#{file}", path_props],
                       ],
                       infos)

          infos = []
          session.file_revs2(file, rev1, rev2) do |_path, rev, rev_props, prop_diffs|
            infos << [rev, _path, prop_diffs]
          end
          assert_equal([
                         [rev1, "/#{file}", {}],
                         [rev2, "/#{file}", path_props],
                       ],
                       infos)

          assert_equal({}, session.get_locks(""))
          locks = []
          session.lock({file => rev2}) do |_path, do_lock, lock, ra_err|
            locks << [_path, do_lock, lock, ra_err]
          end
          assert_equal([file],
                       locks.collect{|_path, *rest| _path}.sort)
          lock = locks.assoc(file)[2]
          assert_equal(["/#{file}"],
                       session.get_locks("").collect{|_path, *rest| _path})
          assert_equal(lock.token, session.get_lock(file).token)
          assert_equal([lock.token],
                       session.get_locks(file).values.collect{|l| l.token})
          session.unlock({file => lock.token})
          assert_equal({}, session.get_locks(file))
        end
      end
    end
  end

  def assert_property_access
    log = "sample log"
    file = "sample.txt"
    path = File.join(@wc_path, file)
    make_context(log) do |ctx|
      config = {}
      callbacks = Svn::Ra::Callbacks.new(ctx.auth_baton)
      Svn::Ra::Session.open(@repos_uri, config, callbacks) do |session|