tfs_graph 0.1.1 → 0.1.2

data/spec/persistable_entity_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+require 'tfs_graph/repository'
+require 'tfs_graph/repository_registry'
+require 'tfs_graph/persistable_entity'
+
+require 'tfs_graph/branch'
+require 'tfs_graph/project'
+require 'tfs_graph/changeset'
+
+describe TFSGraph::PersistableEntity do
+  Given(:repo_class) { flexmock("FakeRepository") }
+  Given(:repo) { flexmock("fake repository instance") }
+  Given { TFSGraph::RepositoryRegistry.register {|r| r.type repo_class } }
+
+  Given { repo_class.should_receive(:new).and_return(repo) }
+
+  shared_examples "an entity" do
+    context "knows when it is not persisted" do
+      Then { entity.should_not be_persisted }
+      And { repo.should_not have_received(:save) }
+    end
+
+    context "can be persisted" do
+      Given { repo.should_receive(:save).with(entity).and_return { entity.persist 1, flexmock(id: 1) } }
+      When { entity.save! }
+      Then { entity.should be_persisted }
+      And { entity.id.should == 1 }
+    end
+
+    context "can convert to a hash" do
+      When(:result) { entity.to_hash }
+      Then { result.keys.should == (entity.send(:schema).keys << :id).uniq }
+    end
+
+    context "can get repo for self" do
+      When(:me) { entity.class.repository }
+      Then { me.should eq repo }
+    end
+  end
+
+  context "branch" do
+    it_should_behave_like "an entity" do
+      Given(:entity) { TFSGraph::Branch.new(repo, name: "Demo", created: Time.now) }
+
+      context "has properties" do
+        Then { entity.name.should == "Demo" }
+        And { entity.archived.should == "false" }
+        And { entity.created.should be_a Time }
+      end
+    end
+
+    context "time converter" do
+      Given(:time) { Time.now }
+
+      context "can rebuild time from unixtime" do
+        When(:entity) { TFSGraph::Branch.new(repo, name: "Demo", created: time.to_i) }
+        Then { entity.created.to_i.should eq(time.to_i) }
+      end
+
+      context "can rebuild time from Time" do
+        When(:entity) { TFSGraph::Branch.new(repo, name: "Demo", created: time) }
+        Then { entity.created.to_i.should eq(time.to_i) }
+      end
+    end
+  end
+
+  context "changeset" do
+    it_should_behave_like "an entity" do
+      Given(:entity) { TFSGraph::Changeset.new(repo, committer: "James") }
+
+      context "has properties" do
+        Then { entity.committer.should == "James" }
+        And { entity.branch_path.should be_nil }
+        And { entity.comment.should be_nil }
+      end
+    end
+  end
+
+  context "project" do
+    it_should_behave_like "an entity" do
+      Given(:entity) { TFSGraph::Project.new(repo, name: "FooBarge") }
+
+      context "has properties" do
+        Then { entity.name.should == "FooBarge" }
+        And { entity.last_updated.should eq(Time.at(0).utc) }
+      end
+    end
+  end
+
+end

data/spec/project_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+require 'tfs_graph/project'
+
+describe TFSGraph::Project do
+  Given(:repo) { flexmock("FakeRepository") }
+  Given(:project) { TFSGraph::Project.new(repo, {name: "Fake Project"}) }
+
+  context "last updated is not available if never updated" do
+    Then { project.last_updated.should == Time.at(0).utc }
+  end
+
+  context "last updated is a date if set" do
+    Given(:time) { Time.now }
+    Given(:project) { TFSGraph::Project.new(repo, {name: "Fake Project", last_updated: time }) }
+    Then { project.last_updated.should == time }
+  end
+
+  context "can set last updated" do
+    before { Timecop.freeze }
+    after { Timecop.return }
+
+    Given(:project) { TFSGraph::Project.new(repo, {name: "Fake Project"}) }
+    Given { repo.should_receive(:save).with(project).and_return { project.persist 1, flexmock(id: 1) }}
+    When { project.updated! }
+    Then { project.last_updated.should eq(Time.now.utc) }
+    And { project.should be_persisted }
+  end
+end

data/spec/related_repository_integration_spec.rb

@@ -0,0 +1,328 @@
+require 'spec_helper'
+
+require 'tfs_graph/repository/related_repository'
+require 'tfs_graph/server_registry'
+require 'tfs_graph/repository_registry'
+
+require 'tfs_graph/associators/changeset_tree_builder'
+require 'tfs_graph/changeset_merge'
+
+# Integration testing between:
+# - different repos
+# - the registry
+# - objects the repo returns
+
+describe "Related repo integration" do
+  before :all do
+    TFSGraph::ServerRegistry.register {|r| r.redis url: "redis://localhost:6379", namespace: "test" }
+  end
+
+  after(:each) do
+    TFSGraph::ServerRegistry.server.drop_all
+  end
+
+  Given(:register) { TFSGraph::RepositoryRegistry.register {|r| r.type TFSGraph::Repository::RelatedRepository }}
+  Given(:project_repo) { register.project_repository }
+  Given { 3.times {|i| project_repo.create(name: "TestProject_#{i}") }}
+  Given { 2.times {|i| project_repo.create(name: "TestProject_#{i+7}", hidden: true) }}
+  Given(:foo) { project_repo.create(name: "TestProject_Foo") }
+
+  context "project lookups" do
+    context "can lookup all projects" do
+      When(:all) { project_repo.all }
+      Then { all.count.should == 5 }
+      And { all.all? {|p| p.is_a? TFSGraph::Project }.should be_true }
+    end
+
+    context "can lookup active projects only" do
+      When(:all) { project_repo.active }
+      Then { all.count.should == 3 }
+    end
+
+    context "can lookup by id" do
+      When(:project) { project_repo.find foo.id }
+      Then { project.should == foo }
+    end
+
+    context "can lookup project by name" do
+      When(:project) { project_repo.find_by_name foo.name }
+      Then { project.name.should == foo.name }
+    end
+
+    context "throws not found error if id not found" do
+      When(:result) { project_repo.find 123 }
+      Then { result.should have_failed(TFSGraph::Repository::NotFound)}
+    end
+
+    context "throws not found error if name found" do
+      When(:result) { project_repo.find "FakeProject" }
+      Then { result.should have_failed(TFSGraph::Repository::NotFound)}
+    end
+  end
+
+  context "branches" do
+    Given(:branch_repo) { register.branch_repository }
+    Given { 3.times do |i|
+        branch = branch_repo.create(path: "$/Root/Branch-#{i}", original_path: "$/Root/Branch-#{i}")
+        foo.add_branch(branch)
+      end
+    }
+
+    context "can find project for branch" do
+      Given(:branch) {
+        branch_repo.create(
+          path: "$/Root/Branch-Base",
+          original_path: "$/Root/Branch-Base",
+          project: "TestProject_Foo"
+        )
+      }
+      When(:project) { branch_repo.project_for_branch branch }
+      Then { project.should eq(foo) }
+    end
+
+    context "branch lookups through a project" do
+      When(:branches) { foo.branches }
+      Then { branches.size.should eq(3) }
+      And { branches.all? {|p| p.is_a? TFSGraph::Branch }.should be_true }
+    end
+
+    context "can get specific branch for a project by path" do
+      When(:branch) { branch_repo.find_in_project(foo, "$/Root/Branch-1") }
+      Then { branch.should_not be_nil }
+      And { branch.path.should eq("$/Root/Branch-1") }
+    end
+
+    context "project's branches" do
+      Given(:archived_branch) {
+        branch_repo.create(
+          path: "$/Root/Branch-Base",
+          original_path: "$/Root/Archived/Branch-Base",
+          project: "TestProject_Foo",
+        )
+      }
+      Given(:hidden_branch) {
+        branch_repo.create(
+          path: "$/Root/Branch-Base",
+          original_path: "$/Root/Branch-Boot",
+          project: "TestProject_Foo",
+          hidden: true
+        )
+      }
+      Given { foo.add_branch(archived_branch) }
+      Given { foo.add_branch(hidden_branch) }
+
+      context "active branches for a project" do
+        When(:active) { foo.active_branches }
+        Then { active.size.should eq(3) }
+      end
+
+      context "all non-hidden branches for a project" do
+        When(:visible) { foo.branches }
+        Then { visible.size.should eq(4) }
+      end
+
+      context "all with hidden" do
+        When(:all) { foo.branches_with_hidden }
+        Then { all.size.should eq(5) }
+      end
+    end
+
+    shared_examples "branch type" do |type, name, root|
+      Given { TFSGraph::ServerRegistry.redis.flushall }
+      Given(:normal) {
+        branch_repo.create(
+          path: "$/Root/#{name}",
+          original_path: "$/Root/#{name}",
+          root: root,
+          name: name
+        )
+      }
+      Given(:archived) {
+        branch_repo.create(
+          path: "$/Root/#{name}",
+          original_path: "$/Root/Archived/#{name}",
+          root: root,
+          name: name
+        )
+      }
+      Given(:hidden) {
+        branch_repo.create(
+          path: "$/Root/#{name}",
+          original_path: "$/Root/#{name}",
+          root: root,
+          name: name,
+          hidden: true
+        )
+      }
+      Given { foo.add_branch(normal) }
+      Given { foo.add_branch(archived) }
+      Given { foo.add_branch(hidden) }
+
+      context "can find the #{type}s" do
+        When(:results) { foo.send "#{type}s" }
+        Then { results.size.should eq(2) }
+      end
+
+      context "can find the hidden #{type}s" do
+        When(:results) { foo.send "#{type}s_with_hidden" }
+        Then { results.size.should eq(3) }
+      end
+
+      context "can find the archived #{type}s" do
+        When(:results) { foo.send "archived_#{type}s" }
+        Then { results.size.should eq(1) }
+      end
+    end
+
+    context "can get the master branches" do
+      it_should_behave_like "branch type", "master", "Branch-Cool", ""
+    end
+
+    context "can get the release branches" do
+      it_should_behave_like "branch type", "release", "Branch-R22-1234", "Branch-Cool"
+    end
+
+    context "can get the feature" do
+      it_should_behave_like "branch type", "feature", "Branch-Base-Boot", "Branch-Cool"
+    end
+
+    context "changeset lookups" do
+      Given(:cs_repo) { register.changeset_repository }
+      Given(:branch) { foo.branches.first }
+      Given!(:changesets) {
+        3.times.map do |i|
+          cs = cs_repo.create(comment: "Never gonna let you down.", id: "123#{i}".to_i, committer: "John Gray the #{i}th", created: i.days.ago)
+          branch.add_changeset(cs)
+          cs
+        end
+      }
+      Given!(:noise) {
+        # some extra noise
+        3.times.map do |i|
+          cs = cs_repo.create(comment: "Never gonna give you up.", id: "323#{i}".to_i, commiter: "Jim Beam", created: i.days.ago)
+          foo.branches[1].add_changeset(cs)
+          cs
+        end
+      }
+      Given { TFSGraph::ChangesetTreeBuilder.to_tree branch, changesets }
+
+      context "paths are set" do
+        When(:cs) { branch.changesets }
+        Then { cs.map(&:branch_path).all? {|path| path == branch.path }.should be_true }
+        And { cs.all? {|b| b.is_a? TFSGraph::Changeset }.should be_true }
+      end
+
+      context "from a project" do
+        context "all" do
+          When(:activity) { foo.all_activity }
+          Then { activity.size.should == 6 }
+          And { expect(activity).to match_array(noise.concat(changesets)) }
+        end
+
+        context "all_activity_by_date" do
+          When(:activity) { foo.all_activity_by_date(0.5.days.ago) }
+          Then { activity.values.flatten.size.should == 2 }
+          And { expect(activity.values.flatten.map(&:id)).to match_array([3230, 1230]) }
+        end
+      end
+
+      context "from a branch" do
+        context "branch accessors" do
+          When(:authors) { branch.contributors }
+          Then { expect(authors.keys).to match_array(["John Gray the 0th", "John Gray the 1th", "John Gray the 2th"]) }
+        end
+
+        context "as a tree" do
+
+          context "branch can get it's root node" do
+            When(:root) { branch.root_changeset }
+            Then { root.id.should eq(1230) }
+          end
+
+          context "can get it's last node" do
+            When(:last) { branch.last_changeset }
+            Then { last.id.should eq(1232) }
+          end
+        end
+      end
+
+      context "within changesets" do
+        Given(:changeset) { changesets.first }
+
+        context "can walk the chain" do
+          Given(:results) { [] }
+          When {
+            child = changeset.next
+            loop do
+              results << child.id
+              child = child.next
+            end
+          }
+          Then { results.should match_array([1231, 1232])}
+        end
+
+        context "can get branch" do
+          When(:cs_branch) { changeset.branch }
+          Then { cs_branch.should eq(branch) }
+        end
+      end
+
+      context "with merges" do
+        Given(:merge_attrs) {[
+          {source_version: 1230, target_version: 3230},
+          {source_version: 1231, target_version: 3231},
+          {source_version: 1232, target_version: 3231}
+        ]}
+        Given { merge_attrs.each {|attrs| TFSGraph::ChangesetMerge.create attrs }}
+
+        context "parentage" do
+          Given(:child) { foo.branches[1] }
+          Given { child.root = branch.path; child.send :detect_type; child.save! }
+
+          Then { branch.should be_master }
+
+          context "related branches" do
+            When(:related) { child.related_branches }
+            Then { related.size.should eq(1) }
+            And { related.first.should == branch.id }
+          end
+
+          context "json reports related branches" do
+            When(:data) { JSON.parse child.to_json, symbolize_names: true }
+            Then { data[:related_branches].size.should eq(1) }
+            And { data[:related_branches].should match_array([branch.id]) }
+          end
+
+          context "get absolute root" do
+            When(:root) { child.absolute_root }
+            Then { root.should == branch }
+          end
+
+          context "ahead stats" do
+            When(:ahead) { child.ahead_of_master }
+            Then { ahead.should eq(1) }
+          end
+
+          context "behind stats" do
+            When(:behind) { child.behind_master }
+            Then { behind.should eq(0) }
+          end
+        end
+
+        context "merged changesets" do
+          Given(:changeset) { cs_repo.find(1230) }
+          When(:merges) { changeset.merged }
+          Then { merges.size.should eq(1) }
+          And { merges.map(&:id).should match_array([3230]) }
+        end
+
+        context "merges changesets" do
+          Given(:changeset) { cs_repo.find(3231) }
+          When(:merges) { changeset.merges }
+          Then { merges.size.should eq(2) }
+          And { merges.map(&:id).should match_array([1232, 1231]) }
+        end
+      end
+    end
+  end
+end

data/spec/repository_registry_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+require "tfs_graph/branch"
+require "tfs_graph/changeset"
+require "tfs_graph/project"
+
+require 'tfs_graph/repository'
+require 'tfs_graph/repository_registry'
+
+describe TFSGraph::RepositoryRegistry do
+  Given(:repo) { flexmock(TFSGraph::Repository) }
+  Given(:register) { TFSGraph::RepositoryRegistry.register {|r|
+    r.type repo
+  }}
+
+  def constantize(string)
+    Object.const_get(string)
+  end
+
+  class TFSGraph::Behaviors::Repository
+    module Branch; end
+    module Project; end
+    module Changeset; end
+  end
+
+  shared_examples "a repository builder" do |type|
+    Given {
+      repo.should_receive(:new).
+        with(constantize("TFSGraph::#{type.capitalize}")).pass_thru
+    }
+    When(:entity_repo) { register.send "#{type}_repository" }
+    Then { entity_repo.should be_a(TFSGraph::Repository) }
+    And { register.instance_variable_get("@#{type}_repo").should_not be_nil }
+    And { register.send("#{type}_repository").should == entity_repo }
+  end
+
+  context "Branch" do
+    it_should_behave_like "a repository builder", "branch"
+  end
+
+  context "Changeset" do
+    it_should_behave_like "a repository builder", "changeset"
+  end
+
+  context "Project" do
+    it_should_behave_like "a repository builder", "project"
+  end
+end