depgraph 0.11.0

data/spec/IntegrationTests/depgraph_spec.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'rubygems'
+require 'graph_creator'
+
+include FileTestHelper
+
+default_graph_file = 'dependency_graph.png'
+tool_name = 'depgraph'
+tool_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', tool_name))
+
+describe "#{tool_name} (integration tests)" do
+ 
+  test_data = {
+    :csproj => {'proj1.csproj' => '"proj2.csproj"', 'proj2.csproj' => '"proj1.csproj"'},
+    :ruby_requires => {'rubyfile1.rb' => 'require "rubyfile2"', 'rubyfile2.rb' => 'require "rubyfile3"'},
+    :gems => {}
+  }
+
+  DepGraph::GraphCreator.types.each do |filter_type|
+    it "should create an image from the #{filter_type} dependency type" do
+      test_files = test_data[filter_type]
+      with_files(test_files) do
+        system "ruby \"#{tool_path}\" -type #{filter_type}"
+        
+        non_empty_file_created(default_graph_file).should be_true
+      end
+    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
+      system "ruby \"#{tool_path}\" -type csproj -from file2"
+      
+      File.exist?(default_graph_file).should be_false
+    end
+  end
+  
+  it 'should create a file when the "-from" filter finds matches' do
+    with_files(two_files_with_one_dependency_from_file1_to_file2) do
+      system "ruby \"#{tool_path}\" -type csproj -from file1"
+      
+      File.exist?(default_graph_file).should be_true
+    end
+  end
+  
+  it 'should not create a file when the "-to" filter does not find matches' do
+    with_files(two_files_with_one_dependency_from_file1_to_file2) do
+      system "ruby \"#{tool_path}\" -type csproj -to file1"
+      
+      File.exist?(default_graph_file).should be_false
+    end
+  end
+  
+  it 'should create a file when the "-to" filter finds matches' do
+    with_files(two_files_with_one_dependency_from_file1_to_file2) do
+      system "ruby \"#{tool_path}\" -type csproj -to file2"
+      
+      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,54 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'file_system_node_finder'
+require 'rubygems'
+
+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.sort.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.detect {|n| n.name == 'a'}
+        node.should_not be_nil
+        node.dependencies.should == ['b', 'c']
+      end
+    end
+  end
+end

data/spec/IntegrationTests/gems_node_finder_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'rubygems'
+require 'nodefinders/gems_node_finder'
+
+include FileTestHelper
+include DepGraph::NodeFinders
+
+describe GemsNodeFinder do
+  it "should list all gems and its dependencies" do
+    with_files('fakegem-0.9.1.gemspec' => 's.add_dependency(%q<fakedependencygem>, [">= 1.5.0"])') do
+      gems_node_finder = GemsNodeFinder.new
+      gems_node_finder.location = ['./']
+      nodes = gems_node_finder.get_nodes
+    
+      nodes.should == ['fakedependencygem', 'fakegem']
+      nodes[1].dependencies.size.should == 1
+      nodes[1].dependencies[0].name.should == 'fakedependencygem'
+    end
+  end
+end

data/spec/IntegrationTests/graph_creator_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'graph_creator'
+require 'rubygems'
+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"' },
+  :gems => {}
+}
+
+describe GraphCreator, '(integration tests)' do
+  GraphCreator.types.each do |filter_type|
+    it "should create a png image from the #{filter_type} dependencies found" 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,50 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'graph_image_creator'
+require 'rubygems'
+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/UnitTests/dependency_types_manager_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'dependency_types_manager'
+include DepGraph
+
+describe DependencyTypesManager do
+  
+  it "should return the available filter types" do
+    dependency_types_in_file = YAML.load_file(DependencyTypesManager.dependency_types_file).map do |filter_type_in_file, _| 
+      filter_type_in_file
+    end
+    
+    dependency_types_in_file.should == dependency_types.map {|filter_type| filter_type.to_s}
+  end
+  
+  it "should use default values if the specified filter type is not found" do
+    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
+    dependable_filter_manager.file_name_pattern.should == '*'
+  end
+
+
+  sample_contents = {
+    :ruby_requires => {:content => ['require "something/dependency"',
+                           "  require   'something/dependency.rb'"],
+              :file_pattern => '*.rb'},
+            
+    :csproj => {:content => ['sdff "directory\\dependency.csproj"hyhyhy',
+                             'asdfffd"directory\\anotherdir\\dependency.dll" gfgfgg'],
+                :file_pattern => '*.csproj'}
+  }
+
+  dependency_types.each do |filter_type|
+    it "should have a #{filter_type} filter type" do
+      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|
+          dependable_filter_manager.dependable_regexp.match(sample_dependency).captures[capture_index].should == 'dependency'
+      end
+      dependable_filter_manager.file_name_pattern.should == sample_contents[filter_type][:file_pattern]
+    end
+  end
+end
+

data/spec/UnitTests/file_system_node_finder_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'file_system_node_finder'
+
+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,140 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'graph_creator'
+require 'rubygems'
+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