DepGraph 0.8.0 → 0.9.0

data/spec/{depgraph_spec.rb → IntegrationTests/depgraph_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + "/spec_helper"
+require File.dirname(__FILE__) + "/../spec_helper"
 require 'rubygems'
 gem 'filetesthelper'
 require 'filetesthelper'
@@ -7,7 +7,7 @@ include FileTestHelper
 
 default_graph_file = 'dependency_graph.png'
 tool_name = 'depgraph'
-tool_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', tool_name))
+tool_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', tool_name))
 
 describe "#{tool_name} (integration tests)" do
  
@@ -27,6 +27,7 @@ describe "#{tool_name} (integration tests)" do
     end
   end
   
+  three_files_with_chained_dependencies_from_file1_to_file2_to_file3 = {'file1.csproj' => '"file2.csproj"', 'file2.csproj' => '"file3.csproj"', 'file3.csproj' => ''}
   two_files_with_one_dependency_from_file1_to_file2 = {'file1.csproj' => '"file2.csproj"', 'file2.csproj' => ''}
   it 'should not create a file when the "-from" filter does not find matches' do
     with_files(two_files_with_one_dependency_from_file1_to_file2) do
@@ -59,6 +60,31 @@ describe "#{tool_name} (integration tests)" do
       File.exist?(default_graph_file).should be_true
     end
   end
+  
+  it 'should exclude nodes when the "-exc" filter is used' do
+    with_files(three_files_with_chained_dependencies_from_file1_to_file2_to_file3) do
+      system "ruby #{tool_path} -type csproj -exc \"file2, ile3\""
+      
+      File.exist?(default_graph_file).should be_false #because only file1 exists
+    end
+  end
+  
+  it 'should be possible to load the test node finder found in the nodefinders directory' do
+    with_files() do
+      system "ruby #{tool_path} -type test"
+      
+      File.exist?(default_graph_file).should be_true
+    end
+  end
+  
+  it 'should be possible apply a transitive reduction to the output graph' do
+    with_files() do
+      system "ruby #{tool_path} -type test -trans"
+      
+      File.exist?(default_graph_file).should be_true
+      File.exist?('temp.dot').should be_false
+    end
+  end
 end
 
 

data/spec/IntegrationTests/file_system_node_finder_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'file_system_node_finder'
+require 'rubygems'
+gem 'filetesthelper'
+require 'filetesthelper'
+require 'spec'
+
+include FileTestHelper
+include DepGraph
+
+describe FileSystemNodeFinder, '(integration tests)' do
+  it 'should remove extensions from node names' do
+    with_files('directory1/directory2/file.name.ext' => '') do
+      node_finder = FileSystemNodeFinder.new(non_existent_filter_type)  
+      node_finder.file_name_pattern = '*ext'
+      nodes = node_finder.get_nodes
+      nodes.should == ['file.name']
+    end
+  end
+
+  it 'should search only in the specified directories' do
+    with_files('good1/file1' => '', 'good2/file2' => '', 'bad/file3' => '') do
+      node_finder = FileSystemNodeFinder.new(non_existent_filter_type)
+      node_finder.location = ['good1', 'good2']
+        
+      nodes = node_finder.get_nodes
+      nodes.should == ['file1', 'file2']
+    end
+  end
+end
+
+#To setup the test files for each filter type, include three sample node files
+#and make the first file, named 'a' depend on the next two, named 'b' and 'c'
+test_set = {
+  :ruby_requires => {'a.rb' => 'require "b"\nrequire "c"', 'dir/b.rb' => '', 'dir/c.rb' => '', 'not_a_ruby_file' => ''},
+  :csproj => {'a.csproj' => '"b.csproj"\n"c.csproj"', 'dir/b.csproj' => '', 'dir/c.csproj' => '', 'not_a_csproj_file' => ''}
+}
+  
+dependency_types.each do |filter_type|
+  test_files = test_set[filter_type]
+  
+  describe FileSystemNodeFinder, "for #{filter_type.to_s} (integration tests)" do
+    it "should find the correct number of nodes" do
+      with_files(test_files) do
+        nodes = FileSystemNodeFinder.new(filter_type).get_nodes
+        nodes.should == ['a', 'b', 'c']
+      end
+    end
+    it "should correctly find the dependencies from each file" do
+      with_files(test_files) do
+        node = FileSystemNodeFinder.new(filter_type).get_nodes[0]
+        node.should_not be_nil
+        node.dependencies.should == ['b', 'c']
+      end
+    end
+  end
+end

data/spec/IntegrationTests/graph_creator_spec.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'graph_creator'
+require 'rubygems'
+gem 'filetesthelper'
+require 'spec'
+require 'filetesthelper'
+include DepGraph
+include FileTestHelper
+  
+test_data = {
+  :csproj => {'file1.csproj'=>'"file2.csproj"', 'dir/file2.csproj'=>'"file1.csproj"' },
+  :ruby_requires => {'file1.rb'=>'require "file2"', 'dir/file2.rb'=>'require "file1"' }
+}
+
+describe GraphCreator, '(integration tests)' do
+  dependency_types.each do |filter_type|
+    it "should create a png image from the #{filter_type} dependencies found in the current directory tree" do
+      with_files(test_data[filter_type]) do
+        GraphCreator.new(filter_type).create_image('test.png')
+      
+        non_empty_file_created('test.png').should be_true
+      end
+    end
+  end
+end  
+
+
+
+
+
+
+

data/spec/IntegrationTests/graph_image_creator_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'graph'
+require 'rubygems'
+gem 'filetesthelper'
+require 'spec'
+require 'filetesthelper'
+include FileTestHelper
+include DepGraph
+
+describe GraphImageCreator, '(integration tests)' do
+  it "should create a file with the graph image" do
+    with_files do
+      graph = create_graph_with_2_nodes_and_1_edge    
+      graph.create_image('graph.png')
+
+      non_empty_file_created('graph.png').should be_true
+    end
+  end
+  
+  it "should not create an image file from an empty graph" do
+    with_files do
+      create_empty_graph.create_image('graph.png')
+      non_empty_file_created('graph.png').should be_false
+    end
+  end
+  
+  it "should not create an image file from a graph with no edges" do
+    with_files do
+      create_graph_with_2_nodes_and_0_edges.create_image('graph.png')
+      
+      non_empty_file_created('graph.png').should be_false
+    end
+  end
+  
+  it 'can change output generation behaviour'do
+    graph = create_graph_with_2_nodes_and_1_edge
+    graph.output_generation = no_output_generation
+    with_files do
+      graph.create_image('test.png')
+      File.exist?('test.png').should be_false
+    end
+  end
+  
+  it 'can generate dot script'do
+    graph = create_graph_with_2_nodes_and_1_edge
+    with_files do
+      graph.create_image('test.dot')
+      File.exist?('test.dot').should be_true
+      File.read('test.dot').match('digraph G').should_not be_nil
+    end
+  end
+end
+

data/spec/{dependable_filter_manager_spec.rb → UnitTests/dependency_types_manager_spec.rb}

@@ -1,13 +1,13 @@
-require File.dirname(__FILE__) + "/spec_helper"
+require File.dirname(__FILE__) + "/../spec_helper"
 require 'rubygems'
 require 'spec'
-require 'dependable_filter_manager'
+require 'dependency_types_manager'
 include DepGraph
 
-describe DependableFilterManager do
+describe DependencyTypesManager do
   
   it "should return the available filter types" do
-    dependency_types_in_file = YAML.load_file(DependableFilterManager.dependency_types_file).map do |filter_type_in_file, _| 
+    dependency_types_in_file = YAML.load_file(DependencyTypesManager.dependency_types_file).map do |filter_type_in_file, _| 
       filter_type_in_file
     end
     
@@ -15,7 +15,7 @@ describe DependableFilterManager do
   end
   
   it "should use default values if the specified filter type is not found" do
-    dependable_filter_manager = DependableFilterManager.new non_existent_filter_type
+    dependable_filter_manager = DependencyTypesManager.new non_existent_filter_type
     
     dependable_filter_manager.dependable_regexp.should == /.+/
     dependable_filter_manager.dependable_regexp_capture_group_index.should == 0
@@ -35,7 +35,7 @@ describe DependableFilterManager do
 
   dependency_types.each do |filter_type|
     it "should have a #{filter_type} filter type" do
-      dependable_filter_manager = DependableFilterManager.new filter_type
+      dependable_filter_manager = DependencyTypesManager.new filter_type
     
       capture_index = dependable_filter_manager.dependable_regexp_capture_group_index
       sample_contents[filter_type][:content].each do |sample_dependency|

data/spec/UnitTests/file_system_node_finder_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'file_system_node_finder'
+require 'rubygems'
+require 'spec'
+
+include DepGraph
+
+describe FileSystemNodeFinder do
+  it 'should be able to get the dependencies to csproj and dll files from a string' do
+    node_finder = FileSystemNodeFinder.new(:csproj)  
+    node = Node.new('a')
+    dependencies_string = 'from this string the dependable to "\\a.dir\\node1.csproj", \n"\\tgg.hyhy\\node2.dll" and "node3.csproj" should be found'
+    
+    node_finder.load_dependencies_from_string(node, dependencies_string)
+
+    node.dependencies.should == ["node1", "node2", "node3"]
+  end
+  
+  it 'should be able to use a custom regexp filter to get the node dependencies from a string' do
+    node_finder = FileSystemNodeFinder.new(non_existent_filter_type)  
+    dependencies_string = 'from this string the dependable to node.csproj \n and node1.dll should be found'
+    node_finder.dependable_filter = /\s([^\s]+)\.(csproj|dll)[^\w]/
+    node_finder.dependable_filter_capture_group_index = 0
+    node = Node.new('a')
+    
+    node_finder.load_dependencies_from_string(node, dependencies_string)
+
+    node.dependencies.should == ["node", "node1"]
+  end
+  
+  it 'should be able to use a capture group in the dependable regexp filter' do
+    node_finder = FileSystemNodeFinder.new(non_existent_filter_type)  
+    dependencies_string = 'from this string the dependable to prefix.node.csproj \n and prefix.node1.dll should be found'
+    node_finder.dependable_filter = /\s(prefix\.)([^\s]+)\.(csproj|dll)[^\w]/
+    node_finder.dependable_filter_capture_group_index = 1 
+    node = Node.new('a')
+    
+    node_finder.load_dependencies_from_string(node, dependencies_string)
+
+    node.dependencies.should == ["node", "node1"]
+  end
+  
+  it 'should ignore repeated dependencies in the string' do
+    node_finder = FileSystemNodeFinder.new(:csproj)  
+    node = Node.new('a')
+    dependencies_string = 'this string has only one dependable that is repeated 3 times: "\\a.dir\\node.csproj", \n"\\tgg.hyhy\\node.dll" and "node.csproj"'
+    
+    node_finder.load_dependencies_from_string(node, dependencies_string)
+
+    node.dependencies.should == ["node"]
+  end
+  
+  it 'should ignore the capture group index if the dependable filter regexp has no capture groups' do
+    node_finder = FileSystemNodeFinder.new(non_existent_filter_type)  
+    node_finder.dependable_filter = /dep[0-9]/
+    node_finder.dependable_filter_capture_group_index = 1 
+    node = Node.new('a')
+    
+    node_finder.load_dependencies_from_string(node, 'dep1 is in the first line \n in the second dep2')
+    
+    node.dependencies.size.should == 2
+  end
+end
+

data/spec/UnitTests/graph_creator_spec.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'graph_creator'
+require 'rubygems'
+require 'spec'
+include DepGraph
+  
+describe GraphCreator do
+  it 'should not create a file if the graph is empty' do
+    create_graph_creator_with_no_nodes.create_image.should be_false
+  end
+
+  it 'should return an empty graph if an empty set of nodes is specified' do
+    graph = create_graph_creator_with_two_nodes_and_no_dependencies.create_graph
+    
+    graph.node_count.should == 0
+    graph.edge_count.should == 0
+
+  end
+  
+  it 'should return an empty graph if only one node is specified' do
+    graph = create_graph_creator_with_two_nodes_and_no_dependencies.create_graph
+    
+    graph.node_count.should == 0
+    graph.edge_count.should == 0
+
+  end
+  
+  it 'should return an empty graph if all nodes specified are equal' do
+    graph = create_graph_creator_with_two_nodes_and_no_dependencies.create_graph
+    
+    graph.node_count.should == 0
+    graph.edge_count.should == 0
+
+  end
+  
+  it 'should ignore disconnected nodes' do
+    graph = create_2_connected_and_1_disconnected_node_with_an_orphan_dependency_graph_creator.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+  end
+  
+  it 'should ignore dependencies to non existent nodes' do
+    graph = create_2_node_graph_creator_with_1_normal_and_1_orphan_dependency.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+  end
+  
+  it 'should return a graph with one edge if two nodes with one dependable are specified' do
+    graph = create_graph_creator_with_two_nodes_and_one_dependency.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+  end
+  
+  it 'should be possible to filter dependent nodes with a regular expression' do
+    graph_creator = create_dependency_chain_graph_creator('node1', 'node2', 'node3', 'node4')
+    graph_creator.from = 'e2$'
+    graph = graph_creator.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+    dependency_exists?(graph, 'node2', 'node3').should be_true
+  end
+  
+  it 'should be possible to filter dependable nodes with a regular expression' do
+    graph_creator = create_dependency_chain_graph_creator('node1', 'node2', 'node3', 'node4')
+    graph_creator.to = 'e4$'
+    graph = graph_creator.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+    dependency_exists?(graph, 'node3', 'node4').should be_true
+  end
+  
+  it 'should exclude user selected nodes' do
+    graph_creator = create_dependency_chain_graph_creator('node1', 'node2', 'anode3', 'node4isthisone')
+    graph_creator.excluded_nodes = ['node3', 'node4', 'node6']
+    graph = graph_creator.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+    dependency_exists?(graph, 'node1', 'node2').should be_true
+  end
+  
+  it 'should not show disconnected nodes' do
+    graph = create_2_connected_plus_2_disconnected_nodes_graph_creator.create_graph
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+  end
+  
+  it 'should not show nodes that are only connected to excluded nodes' do
+    graph_creator = create_dependency_chain_graph_creator('node1', 'node2', 'node3', 'node4')
+    graph_creator.excluded_nodes = ['node3']
+    graph = graph_creator.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+    dependency_exists?(graph, 'node1', 'node2').should be_true
+  end
+  
+  it 'should notify sucessful image creation' do
+    graph_creator = create_graph_creator_with_two_nodes_and_one_dependency
+    graph_creator.graph_image_creator_class = NoOutputGraph
+    graph_creator.create_image('graph.png').should be_true
+  end
+  
+  it 'should notify failed image creation' do
+    graph_creator = create_graph_creator_with_no_nodes
+    graph_creator.graph_image_creator_class = NoOutputGraph
+    graph_creator.create_image('graph.png').should be_false
+  end
+  
+  it 'should dynamically load node finders based on the dependency type' do
+    module DepGraph::NodeFinders
+      class FakeNodeFinder
+        def location=(d) end
+        def get_nodes
+          d1 = Node.new('node1')
+          d2 = Node.new('node2')
+          d1.depends_on(d2)
+          [d1, d2]
+        end
+      end
+    end
+    
+    graph = GraphCreator.new(:fake).create_graph
+
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+    dependency_exists?(graph, 'node1', 'node2').should be_true
+  end
+  
+  invalid_graph_creators.each do |invalid_graph_creator_description, invalid_graph_creator|  
+    it "should return false when trying to create an image from a #{invalid_graph_creator_description}" do
+      invalid_graph_creator.graph_image_creator_class = NoOutputGraph
+      invalid_graph_creator.create_image('graph.png').should be_false
+    end
+  end
+end

data/spec/UnitTests/graph_image_creator_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'graph_image_creator'
+require 'rubygems'
+require 'spec'
+include DepGraph
+
+describe GraphImageCreator do
+  
+  it "should start with no nodes" do
+    create_empty_graph.node_count.should == 0
+  end
+  
+  it "should be possible to add nodes" do
+    graph = create_graph_with_2_nodes_and_0_edges
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 0
+  end
+  
+  it "should not be allowed to add a node without a name" do
+    lambda {create_empty_graph.add_node('')}.should raise_error
+  end
+  
+  it "should start with no edges" do
+    create_empty_graph.edge_count.should == 0
+  end
+  
+  it "should be possible to add an edge" do
+    graph = create_graph_with_2_nodes_and_1_edge
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+  end
+  
+  it "can be reset" do
+    graph = create_graph_with_2_nodes_and_1_edge
+    
+    graph.reset
+    graph.node_count.should == 0
+    graph.edge_count.should == 0
+  end
+    
+  it "should not be allowed to add edges between non existent nodes" do
+    lambda {create_empty_graph.add_edge('no node 1', 'no node 2')}.should raise_error
+  end
+  
+  it "should return true when a new image file is created" do
+    graph = create_graph_with_2_nodes_and_1_edge    
+    graph.output_generation = no_output_generation
+    graph.create_image('graph.png').should be_true
+  end
+  
+  it "should return false when trying to create an empty graph" do
+    graph = create_empty_graph
+    graph.output_generation = no_output_generation
+    graph.create_image('graph.png').should be_false
+  end
+end

data/spec/UnitTests/node_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'stringio'
+require 'node' 
+require 'rubygems'
+require 'spec'
+include DepGraph
+
+describe Node do
+  it 'should not accept empty uris in the constructor' do
+    lambda{Node.new('')}.should raise_error
+  end
+  
+  it 'should have a non empty name' do
+    node = Node.new('a')
+    node.name.should_not be_empty
+  end
+
+  it 'should be equal to another node with the same name' do
+    node1 = Node.new('abc')
+    node2 = Node.new('abc')
+    node3 = Node.new('abd')
+    
+    node1.should == node2
+    node1.should be_eql(node2)
+
+    node1.should_not == node3
+    node1.should_not be_eql(node3)
+    
+    node2.should_not == node3
+    node2.should_not be_eql(node3)
+  end
+  
+  it 'should allow setting node dependencies' do
+    node = Node.new('a')
+    node.depends_on('b')
+    
+    node.dependencies.size.should == 1
+  end
+  
+  it 'should allow querying for a node' do
+    node = Node.new('a')
+    node.depends_on('b')
+    
+    node.depends_on?('b').should be_true
+    node.depends_on?('c').should be_false
+  end
+end

data/spec/integration_spec.opts

@@ -0,0 +1,5 @@
+--format
+specdoc
+--timeout
+20
+--diff