dolt 0.5.1 → 0.6.0

data/test/dolt/repo_actions_test.rb

@@ -1,236 +0,0 @@
-# encoding: utf-8
-#--
-#   Copyright (C) 2012 Gitorious AS
-#
-#   This program is free software: you can redistribute it and/or modify
-#   it under the terms of the GNU Affero General Public License as published by
-#   the Free Software Foundation, either version 3 of the License, or
-#   (at your option) any later version.
-#
-#   This program is distributed in the hope that it will be useful,
-#   but WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#   GNU Affero General Public License for more details.
-#
-#   You should have received a copy of the GNU Affero General Public License
-#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#++
-require "test_helper"
-require "dolt/repo_actions"
-require "dolt/async/when"
-require "ostruct"
-
-class Repository
-  attr_reader :name
-  def initialize(name); @name = name; end
-  def tree(ref, path); stub; end
-  def rev_parse(rev); stub; end
-  def blame(ref, path); stub; end
-  def log(ref, path, limit); stub; end
-  def refs; stub; end
-  def tree_history(ref, path, count); stub; end
-
-  def resolve_promise(blob)
-    @deferred.resolve(blob)
-  end
-
-  private
-  def stub
-    @deferred = When::Deferred.new
-    @deferred.promise
-  end
-end
-
-class Resolver
-  attr_reader :resolved
-  def initialize; @resolved = []; end
-
-  def resolve(repo)
-    repository = Repository.new(repo)
-    @resolved << repository
-    repository
-  end
-end
-
-describe Dolt::RepoActions do
-  before do
-    @resolver = Resolver.new
-    @actions = Dolt::RepoActions.new(@resolver)
-  end
-
-  describe "#blob" do
-    it "resolves repository" do
-      @actions.blob("gitorious", "master", "app")
-
-      assert_equal ["gitorious"], @resolver.resolved.map(&:name)
-    end
-
-    it "yields path, blob, repo, ref and base_tree_url to block" do
-      data = nil
-      @actions.blob("gitorious", "babd120", "app") do |err, d|
-        data = d
-      end
-
-      @resolver.resolved.last.resolve_promise("Blob")
-
-      assert_equal({
-                     :blob => "Blob",
-                     :repository => "gitorious",
-                     :ref =>  "babd120",
-                     :path => "app"
-                   }, data)
-    end
-  end
-
-  describe "#tree" do
-    it "resolves repository" do
-      @actions.tree("gitorious", "master", "app")
-
-      assert_equal ["gitorious"], @resolver.resolved.map(&:name)
-    end
-
-    it "yields tree, repo and ref to block" do
-      data = nil
-      @actions.tree("gitorious", "babd120", "app") do |err, d|
-        data = d
-      end
-
-      repo = @resolver.resolved.last
-      repo.resolve_promise "Tree"
-
-      expected = {
-        :tree => "Tree",
-        :repository => "gitorious",
-        :ref =>  "babd120",
-        :path => "app"
-      }
-      assert_equal expected, data
-    end
-  end
-
-  describe "#blame" do
-    it "resolves repository" do
-      @actions.blame("gitorious", "master", "app")
-
-      assert_equal ["gitorious"], @resolver.resolved.map(&:name)
-    end
-
-    it "yields blame, repo and ref to block" do
-      data = nil
-      @actions.blame("gitorious", "babd120", "app") do |err, d|
-        data = d
-      end
-
-      repo = @resolver.resolved.last
-      repo.resolve_promise "Blame"
-
-      expected = {
-        :blame => "Blame",
-        :repository => "gitorious",
-        :ref =>  "babd120",
-        :path => "app"
-      }
-      assert_equal expected, data
-    end
-  end
-
-  describe "#history" do
-    it "resolves repository" do
-      @actions.history("gitorious", "master", "app", 1)
-
-      assert_equal ["gitorious"], @resolver.resolved.map(&:name)
-    end
-
-    it "yields commits, repo and ref to block" do
-      data = nil
-      @actions.history("gitorious", "babd120", "app", 2) do |err, d|
-        data = d
-      end
-
-      repo = @resolver.resolved.last
-      repo.resolve_promise "History"
-
-      expected = {
-        :commits => "History",
-        :repository => "gitorious",
-        :ref =>  "babd120",
-        :path => "app"
-      }
-      assert_equal expected, data
-    end
-  end
-
-  describe "#refs" do
-    before do
-      @refs = ["refs/stash",
-               "refs/tags/v0.2.1",
-               "refs/tags/v0.2.0",
-               "refs/remotes/origin/master",
-               "refs/heads/libgit2",
-               "refs/heads/master"].map { |n| OpenStruct.new(:name => n) }
-    end
-
-    it "yields repositories, tags and heads" do
-      data = nil
-      @actions.refs("gitorious") { |err, d| data = d }
-
-      repo = @resolver.resolved.last
-      repo.resolve_promise(@refs)
-
-      expected = {
-        :repository => "gitorious",
-        :heads => ["libgit2", "master"],
-        :tags => ["v0.2.1", "v0.2.0"]
-      }
-      assert_equal expected, data
-    end
-  end
-
-  describe "#tree_history" do
-    before do
-      @tree = [{
-          :type => :blob,
-          :oid => "e90021f89616ddf86855d05337c188408d3b417e",
-          :filemode => 33188,
-          :name => ".gitmodules",
-          :history => [{
-            :oid => "906d67b4f3e5de7364ba9b57d174d8998d53ced6",
-            :author => { :name => "Christian Johansen",
-                         :email => "christian@cjohansen.no" },
-            :summary => "Working Moron server for viewing blobs",
-            :date => Time.parse("Mon Sep 10 15:07:39 +0200 2012"),
-            :message => ""
-          }]
-        }, {
-          :type => :blob,
-          :oid => "c80ee3697054566d1a4247d80be78ec3ddfde295",
-          :filemode => 33188,
-          :name => "Gemfile",
-          :history => [{
-            :oid => "26139a3aba4aac8cbf658c0d0ea58b8983e4090b",
-            :author => { :name => "Christian Johansen",
-                         :email => "christian@cjohansen.no" },
-            :summary => "Initial commit",
-            :date => Time.parse("Thu Aug 23 11:40:39 +0200 2012"),
-            :message => ""
-          }]
-        }]
-    end
-
-    it "yields repository, path, ref and history" do
-      data = nil
-      @actions.tree_history("gitorious", "master", "", 1) { |err, d| data = d }
-
-      repo = @resolver.resolved.last
-      repo.resolve_promise(@tree)
-
-      expected = {
-        :repository => "gitorious",
-        :ref => "master",
-        :path => "",
-        :tree => @tree
-      }
-      assert_equal expected, data
-    end
-  end
-end

data/test/dolt/template_renderer_test.rb

@@ -1,122 +0,0 @@
-# encoding: utf-8
-#--
-#   Copyright (C) 2012 Gitorious AS
-#
-#   This program is free software: you can redistribute it and/or modify
-#   it under the terms of the GNU Affero General Public License as published by
-#   the Free Software Foundation, either version 3 of the License, or
-#   (at your option) any later version.
-#
-#   This program is distributed in the hope that it will be useful,
-#   but WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#   GNU Affero General Public License for more details.
-#
-#   You should have received a copy of the GNU Affero General Public License
-#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#++
-require "test_helper"
-require "mocha"
-require "dolt/template_renderer"
-
-module ViewHelper
-  def say_it; "YES"; end
-end
-
-describe Dolt::TemplateRenderer do
-  before { @root = "/dolt/views" }
-
-  it "reads template from file" do
-    File.expects(:read).with("/dolt/views/file.erb").returns("")
-    renderer = Dolt::TemplateRenderer.new("/dolt/views")
-    renderer.render(:file)
-  end
-
-  it "renders template with locals" do
-    File.stubs(:read).returns("<%= name %>!")
-    renderer = Dolt::TemplateRenderer.new(@root)
-
-    assert_equal "Chris!", renderer.render(:file, { :name => "Chris"})
-  end
-
-  it "caches template in memory" do
-    renderer = Dolt::TemplateRenderer.new(@root)
-    File.stubs(:read).returns("Original")
-    renderer.render(:file)
-    File.stubs(:read).returns("Updated")
-
-    assert_equal "Original", renderer.render(:file)
-  end
-
-  it "does not cache template in memory when configured not to" do
-    renderer = Dolt::TemplateRenderer.new(@root, :cache => false)
-    File.stubs(:read).returns("Original")
-    renderer.render(:file)
-    File.stubs(:read).returns("Updated")
-
-    assert_equal "Updated", renderer.render(:file)
-  end
-
-  it "renders template with layout" do
-    renderer = Dolt::TemplateRenderer.new("/", :layout => "layout")
-    File.stubs(:read).with("/file.erb").returns("Template")
-    File.stubs(:read).with("/layout.erb").returns("I give you: <%= yield %>")
-
-    assert_equal "I give you: Template", renderer.render(:file)
-  end
-
-  it "renders template once without layout" do
-    renderer = Dolt::TemplateRenderer.new("/", :layout => "layout")
-    File.stubs(:read).with("/file.erb").returns("Template")
-    File.stubs(:read).with("/layout.erb").returns("I give you: <%= yield %>")
-
-    assert_equal "Template", renderer.render(:file, {}, :layout => nil)
-  end
-
-  it "renders template once with different layout" do
-    renderer = Dolt::TemplateRenderer.new("/", :layout => "layout")
-    File.stubs(:read).with("/file.erb").returns("Template")
-    File.stubs(:read).with("/layout.erb").returns("I give you: <%= yield %>")
-    File.stubs(:read).with("/layout2.erb").returns("I present you: <%= yield %>")
-
-    html = renderer.render(:file, {}, :layout => "layout2")
-
-    assert_equal "I present you: Template", html
-  end
-
-  it "renders templates of specific type" do
-    renderer = Dolt::TemplateRenderer.new("/", :type => :str)
-    File.stubs(:read).with("/file.str").returns("Hey!")
-
-    assert_equal "Hey!", renderer.render(:file)
-  end
-
-  it "renders with helper object" do
-    renderer = Dolt::TemplateRenderer.new("/")
-    renderer.helper(ViewHelper)
-    File.stubs(:read).with("/file.erb").returns("Say it: <%= say_it %>")
-
-    assert_equal "Say it: YES", renderer.render(:file)
-  end
-
-  it "does not leak state across render calls" do
-    renderer = Dolt::TemplateRenderer.new("/")
-    File.stubs(:read).with("/file.erb").returns(<<-TEMPLATE)
-<%= @response %><% @response = "NO" %><%= @response %>
-    TEMPLATE
-
-    assert_equal "NO", renderer.render(:file)
-    assert_equal "NO", renderer.render(:file)
-  end
-
-  it "shares state between template and layout" do
-    renderer = Dolt::TemplateRenderer.new("/", :layout => "layout")
-    File.stubs(:read).with("/file.erb").returns(<<-TEMPLATE)
-<% @response = "NO" %><h1><%= @response %></h1>
-    TEMPLATE
-    tpl = "<title><%= @response %></title><%= yield %>"
-    File.stubs(:read).with("/layout.erb").returns(tpl)
-
-    assert_equal "<title>NO</title><h1>NO</h1>\n", renderer.render(:file)
-  end
-end

data/test/dolt/templates/blame_test.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-#--
-#   Copyright (C) 2012 Gitorious AS
-#
-#   This program is free software: you can redistribute it and/or modify
-#   it under the terms of the GNU Affero General Public License as published by
-#   the Free Software Foundation, either version 3 of the License, or
-#   (at your option) any later version.
-#
-#   This program is distributed in the hope that it will be useful,
-#   but WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#   GNU Affero General Public License for more details.
-#
-#   You should have received a copy of the GNU Affero General Public License
-#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#++
-require "test_helper"
-require "dolt/template_renderer"
-require "dolt/view"
-
-class Blame
-  attr_reader :chunks
-  def initialize(chunks); @chunks = chunks; end
-end
-
-describe "blame template" do
-  include Dolt::ViewTest
-
-  before do
-    @repo = "the-dolt"
-    @template_root = File.join(File.dirname(__FILE__), "..", "..", "..", "views")
-    @committer = {
-      :name => "Christian Johansen",
-      :mail => "christian@cjohansen.no",
-      :time => Time.now
-    }
-  end
-
-  def render(path, blame, options = {})
-    renderer = prepare_renderer(@template_root, options)
-    renderer.render(:blame, {
-                      :blame => blame,
-                      :repository => @repo,
-                      :ref => options[:ref] || "master",
-                      :path => path
-                    })
-  end
-
-  it "renders blame" do
-    blob = Blame.new([{ :oid => "0123456", :committer => @committer, :lines => [] }])
-    markup = render("app/models/repository.rb", blob)
-
-    assert_match /<table class="gts-code-listing">/, markup
-  end
-end

data/test/dolt/templates/blob_test.rb

@@ -1,118 +0,0 @@
-# encoding: utf-8
-#--
-#   Copyright (C) 2012 Gitorious AS
-#
-#   This program is free software: you can redistribute it and/or modify
-#   it under the terms of the GNU Affero General Public License as published by
-#   the Free Software Foundation, either version 3 of the License, or
-#   (at your option) any later version.
-#
-#   This program is distributed in the hope that it will be useful,
-#   but WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#   GNU Affero General Public License for more details.
-#
-#   You should have received a copy of the GNU Affero General Public License
-#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#++
-require "test_helper"
-require "dolt/template_renderer"
-require "dolt/view"
-
-class Blob
-  attr_reader :content
-  def initialize(content); @content = content; end
-end
-
-describe "blob template" do
-  include Dolt::ViewTest
-
-  before do
-    @repo = "the-dolt"
-    @template_root = File.join(File.dirname(__FILE__), "..", "..", "..", "views")
-  end
-
-  def render(path, blob, options = {}, helpers = nil)
-    renderer = prepare_renderer(@template_root, options, helpers)
-    renderer.render(:blob, {
-                      :blob => blob,
-                      :repository => @repo,
-                      :ref => options[:ref] || "master",
-                      :path => path
-                    })
-  end
-
-  it "renders blob without errors" do
-    markup = render("file.txt", Blob.new("Something something"))
-
-    assert_match /Something something/, markup
-  end
-
-  it "renders blob with line numbers" do
-    markup = render("file.txt", Blob.new("One\nTwo\nThree"))
-
-    assert_match /<li.*One.*<\/li>/, markup
-    assert_match /<li.*Two.*<\/li>/, markup
-    assert_match /<li.*Three.*<\/li>/, markup
-  end
-
-  it "renders blob with layout" do
-    markup = render("file.txt", Blob.new("Something something"), :layout => "layout")
-
-    assert_match /Something something/, markup
-  end
-
-  it "renders repo title in page" do
-    @repo = "my-magic-repo"
-    markup = render("file.txt", Blob.new("Something something"), :layout => "layout")
-
-    assert_match "my-magic-repo", markup
-  end
-
-  it "renders links to other views" do
-    markup = render("file.txt", Blob.new("Something something"))
-
-    assert_match "/the-dolt/blame/master:file.txt", markup
-    assert_match "/the-dolt/history/master:file.txt", markup
-    assert_match "/the-dolt/raw/master:file.txt", markup
-  end
-
-  it "renders links to other views for correct ref" do
-    markup = render("file.txt", Blob.new("Something something"), :ref => "123bc21")
-
-    assert_match "/the-dolt/blame/123bc21:file.txt", markup
-    assert_match "/the-dolt/history/123bc21:file.txt", markup
-    assert_match "/the-dolt/raw/123bc21:file.txt", markup
-  end
-
-  it "renders the path clickable" do
-    markup = render("some/deeply/nested/file.txt", Blob.new("Something something"))
-
-    assert_match 'href="/the-dolt/tree/master:some"', markup
-    assert_match 'href="/the-dolt/tree/master:some/deeply"', markup
-    assert_match 'href="/the-dolt/tree/master:some/deeply/nested"', markup
-  end
-
-  describe "with smart blob rendering" do
-    include Dolt::Html
-
-    before do
-      @helpers = [Dolt::View::SingleRepository,
-                  Dolt::View::Breadcrumb,
-                  Dolt::View::Blob,
-                  Dolt::View::SmartBlobRenderer]
-    end
-
-    it "renders markdown as html" do
-      markup = render("file.md", Blob.new("# Cool"), {}, @helpers)
-      assert_equal 1, select(markup, "h1").length
-    end
-
-    it "syntax highlights ruby" do
-      blob = Blob.new("class Person\n  attr_reader :name\nend")
-      markup = render("file.rb", blob, {}, @helpers)
-
-      assert_equal 0, select(markup, "h1").length
-    end
-  end
-end