gexf 0.0.2

data/spec/gexf/edge_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+BOOLEAN_GETTERS = %w(directed? undirected? mutual?)
+
+describe GEXF::Edge do
+
+  let(:id)       { 1 }
+  let(:type)     { nil }
+  let(:source_id)   { 2 }
+  let(:target_id)   { 232 }
+  let(:graph)    { double('graph', :edges => []) }
+  let(:weight)   { nil }
+  let(:label)    { 'my-edge' }
+  let(:options)  { { :graph => graph, :type => type, :weight => weight, :label => label } }
+  let(:arguments){ [id, source_id, target_id, options] }
+
+  subject { GEXF::Edge.new(*arguments) }
+
+  describe "#new" do
+    its(:id)         { should == id.to_s }
+    its(:source_id)  { should == source_id.to_s }
+    its(:target_id)  { should == target_id.to_s }
+    its(:weight)     { should == 1.0 }
+    its(:label)      { should == label }
+    its(:type)       { should == GEXF::Edge::UNDIRECTED }
+
+    [:id, :source_id, :target_id, :graph].each do |param|
+      context "when :#{param} is missing" do
+        let(param) { nil }
+
+        it "raises an ArgumentError" do
+          expect { subject }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    context "non-positive :weight" do
+      let(:weight) { -10 }
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "invalid type" do
+      let(:type) { :FOOBAR }
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  BOOLEAN_GETTERS.each do |method|
+    edge_type     = GEXF::Edge.const_get(method[0..-2].upcase.to_sym)
+    other_getters = BOOLEAN_GETTERS - [method]
+
+    describe(method) do
+      context "when type is :#{edge_type}" do
+        let(:type) { edge_type }
+
+        its(method) { should be_true }
+
+        other_getters.each do |other_type|
+          its(other_type) { should be_false }
+        end
+      end
+    end
+  end
+end

data/spec/gexf/edgeset_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe GEXF::EdgeSet do
+
+  def make_edge(attr={})
+    mock('edge', :source_id   => attr[:source_id],
+                 :target_id   => attr[:target_id],
+                 :directed?   => attr[:type] == GEXF::Edge::DIRECTED,
+                 :undirected? => attr[:type] == GEXF::Edge::UNDIRECTED)
+  end
+
+  let(:source_id)  { '1' }
+  let(:target_id)  { '11' }
+  let(:type)       { GEXF::Edge::DIRECTED  }
+  let(:attrs)      { { :type => type,
+                       :source_id => source_id,
+                       :target_id => target_id }}
+
+  let(:arguments) { [] }
+  let(:edge)      { make_edge(attrs) }
+
+  let(:edge2)     { make_edge(:type => GEXF::Edge::UNDIRECTED,
+                              :source_id => '2',
+                              :target_id => '22') }
+
+  let(:edge3)     { make_edge(:type => GEXF::Edge::DIRECTED,
+                              :source_id => '3',
+                              :target_id => '33') }
+
+  let(:edge4)     { make_edge(:type => GEXF::Edge::DIRECTED,
+                              :source_id => '3',
+                              :target_id => '22') }
+
+
+  let(:edgeset)  { GEXF::EdgeSet.new(*arguments) }
+
+  describe "#<<" do
+    subject { edgeset << edge }
+
+    context "when edge is directed" do
+      it "adds the edge to the @data hash, using the :source_id as key" do
+        subject.to_hash.should have_key(edge.source_id)
+        subject.to_hash.should_not have_key(edge.target_id)
+      end
+    end
+
+    context "when edge is undirected" do
+      let(:type) { GEXF::Edge::UNDIRECTED }
+
+      it "adds the edge to the data hash, using both :source_id, and the :target_id as keys" do
+        subject.to_hash.should have_key(edge.source_id)
+        subject.to_hash.should have_key(edge.target_id)
+      end
+    end
+  end
+
+  describe "#count" do
+    let(:other_edge)  { make_edge(:type => other_edge_type,
+                                  :source_id => '3',
+                                  :target_id => '33') }
+
+    subject { edgeset << edge << other_edge }
+
+    context "when adding two directed edges" do
+      let(:other_edge_type) { GEXF::Edge::DIRECTED }
+
+      it "creates 2 keys in the hash, returns 2" do
+        subject.should have(2).items
+        subject.to_hash.keys.should have(2).items
+      end
+    end
+
+    context "when adding a directed and an undirected edge" do
+      let(:other_edge_type) { GEXF::Edge::UNDIRECTED }
+
+      it "creates 3 keys in the hash, returns 2" do
+        subject.should have(2).items
+        subject.to_hash.keys.should have(3).items
+      end
+    end
+  end
+
+  describe "#map" do
+    subject { edgeset << edge << edge2 << edge3 << edge4 }
+
+    it "returns a list of unique edges" do
+      subject.map(&:source_id).should == ['1', '2', '3', '3']
+      subject.map(&:target_id).should == ['11', '22', '33', '22']
+    end
+
+  end
+
+  describe "#select" do
+    subject { edgeset << edge << edge2 << edge3 }
+
+    it "selects two directed edges" do
+      subject.select(&:directed?).should include(edge, edge3)
+    end
+    it "selects an undirected edge" do
+      subject.select(&:undirected?).should include(edge2)
+    end
+  end
+
+end
+

data/spec/gexf/graph_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe GEXF::Graph do
+  let(:edgetype) { nil }
+  let(:idtype)   { nil }
+  let(:mode)     { nil }
+  let(:opts)     {{ :defaultedgetype => edgetype,
+                    :idtype   => idtype,
+                    :mode     => mode }}
+
+  let(:graph)    { GEXF::Graph.new(opts) }
+
+
+  describe "default getters" do
+    subject { graph }
+
+    context "when params are valid" do
+      its(:defaultedgetype)    { should == GEXF::Edge::UNDIRECTED }
+      its(:idtype)      { should == GEXF::Graph::STRING }
+      its(:mode)        { should == GEXF::Graph::STATIC }
+      its(:nodes)       { should be_empty }
+      its(:edges)       { should be_empty }
+    end
+
+    context "when params are not valid" do
+      [:defaultedgetype, :idtype, :mode].each do |param|
+
+        let(param) { :FOO }
+
+        describe "when #{param} is invalid" do
+          it "raises an argument error" do
+            expect { subject }.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#define_node_attribute" do
+    let(:attr_type)  { GEXF::Attribute::STRING }
+    let(:attr_id)    { nil }
+    let(:default)    { 'home sweet home' }
+    let(:title)      { 'page-title' }
+    let(:attr_opts)  {{ :default => default,
+                        :attr_id => attr_id }}
+
+
+    subject { graph.define_node_attribute(title, attr_opts) }
+
+    it "delegates to @nodes" do
+
+      new_attribute = double('attribute')
+
+      graph.nodes.should_receive(:define_attribute).
+                 with('1', title, attr_opts).
+                 and_return(new_attribute)
+
+      subject.should == new_attribute
+    end
+  end
+
+  describe "#define_edge_attribute" do
+    let(:attr_type)  { GEXF::Attribute::STRING }
+    let(:attr_id)    { nil }
+    let(:default)    { 'home sweet home' }
+    let(:title)      { 'page-title' }
+    let(:attr_opts)  {{ :default => default,
+                        :attr_id => attr_id }}
+
+
+    subject { graph.define_edge_attribute(title, attr_opts) }
+
+    it "delegates to @nodes" do
+
+      new_attribute = double('attribute')
+
+      graph.edges.should_receive(:define_attribute).
+                 with('1', title, attr_opts).
+                 and_return(new_attribute)
+
+      subject.should == new_attribute
+    end
+  end
+
+  describe "#create_node" do
+    let(:node_id)     { 'node_21' }
+    let(:node_opts)   {{ :label => 'my node' }}
+    let(:create_opts) { node_opts }
+
+    before(:each) do
+      @node = mock('node')
+      nodeset = mock('nodeset')
+
+      GEXF::NodeSet.stub(:new).and_return(nodeset)
+      nodeset.should_receive(:<<).at_least(:once).with(@node)
+    end
+
+    context "when :id is provided" do
+      let(:create_opts) { node_opts.merge(:id => node_id) }
+
+      it "uses the id provided to create a node" do
+        GEXF::Node.should_receive(:new).
+                   with(node_id, graph, node_opts).
+                   and_return(@node)
+
+        graph.create_node(create_opts) == @node
+      end
+    end
+
+    context "when :id is not provided" do
+      it "auto-assigns the id using the internal counter" do
+        3.times do |n|
+          GEXF::Node.should_receive(:new).
+                     once.ordered.
+                     with((n+1).to_s, graph, node_opts).
+                     and_return(@node)
+        end
+
+        3.times { graph.create_node(create_opts) }
+      end
+    end
+  end
+
+  describe "#create_edge" do
+    let(:edge_label) { 'bar' }
+    let(:source_id)  { '2' }
+    let(:target_id)  { '32' }
+    let(:source)     { mock('source', :id => source_id) }
+    let(:target)     { mock('target', :id => target_id) }
+    let(:edge_opts)  {{:label => edge_label }}
+
+    subject { graph.create_edge(source, target, edge_opts) }
+
+    before(:each) do
+      @edge   = mock('edge')
+      edgeset = mock('edgeset')
+
+      GEXF::EdgeSet.stub(:new).and_return(edgeset)
+      edgeset.should_receive(:<<).at_least(:once).with(@edge)
+    end
+
+    context "when no :id or :type param is provided" do
+      it "auto-assigns the edge :id using the internal counter, and the :type using :edgetype" do
+
+        GEXF::Edge.should_receive(:new).
+                   with('1', source.id, target.id, edge_opts.merge(:graph => graph,
+                                                                   :type  => graph.defaultedgetype)).
+                   and_return(@edge)
+
+        subject.should == @edge
+      end
+    end
+
+    context "when an :id and a :type are provided" do
+
+      let(:edge_id)   { 'myedge-33' }
+      let(:edge_opts) {{ :label => edge_label,
+                         :id    => edge_id,
+                         :type  => GEXF::Edge::DIRECTED }}
+
+      it "passes the params to the Edge constructor" do
+        expected_opts = edge_opts.reject {|k,v| k == :id }.merge(:graph => graph)
+
+        GEXF::Edge.should_receive(:new).
+                   with(edge_id, source.id, target.id, expected_opts).
+                   and_return(@edge)
+
+        subject.should == @edge
+      end
+    end
+  end
+end

data/spec/gexf/node_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe GEXF::Node do
+
+  let(:indegree)              { GEXF::Attribute.new('1', 'indegree', type: GEXF::Attribute::INTEGER) }
+  let(:outdegree)             { GEXF::Attribute.new('2', 'outdegree', type: GEXF::Attribute::INTEGER) }
+
+  let(:attribute_definitions) {{ '1' => indegree,
+                                 '2' => outdegree }}
+
+  let(:id)                    { 22 }
+  let(:idtype)                { GEXF::Graph::STRING }
+  let(:collection)            { mock('nodeset', :attribute_definitions => attribute_definitions) }
+  let(:edges)                 { mock('edgeset') }
+  let(:graph)                 { double('graph', :nodes => collection, :idtype => idtype, :edges => edges) }
+  let(:label)                 { 'foo' }
+  let(:attributes)            {{ }}
+  let(:options)               {{ :label => label, :attributes => attributes }}
+  let(:arguments)             { [id, graph, options] }
+  let(:node)                  { GEXF::Node.new(*arguments) }
+
+  subject { node }
+
+  it "includes the GEXF::Attribute::Assignable module" do
+    subject.class.include?(GEXF::Attribute::Assignable)
+  end
+
+  context "when graph :idtype is string" do
+    its(:id) { should == id.to_s }
+  end
+
+  context "when graph :idtype is integer" do
+    let(:idtype) { GEXF::Graph::INTEGER }
+    its(:id) { should == id.to_i }
+  end
+
+  describe "#label" do
+    context "option provided" do
+      its(:label) { should == label }
+    end
+    context "option omitted" do
+      let(:options) {{}}
+      its(:label) { should == id.to_s }
+    end
+  end
+
+  describe "attributes" do
+    context "when no attributes are defined" do
+      let(:attribute_definitions) {{}}
+      its(:attributes) { should be_empty }
+    end
+    context "when no attributes are supplied" do
+      its(:attributes) { should == { 'indegree' => nil, 'outdegree' => nil }}
+    end
+    context "when attributes are supplied" do
+      let(:attributes) {{ :outdegree => '24' }}
+      its(:attributes) { should == { 'indegree' => nil, 'outdegree' => 24 }}
+    end
+  end
+
+  describe "#connect_to" do
+
+    let(:edge_opts)  {{ :type => GEXF::Edge::DIRECTED }}
+    let(:other_node) { mock('other_node') }
+    let(:new_edge)   { mock('new-edge') }
+
+    subject { node.connect_to(other_node, edge_opts) }
+
+    it "adds the target to the nodes collection, creates and returns a new edge" do
+
+      collection.should_receive(:<<).with(other_node)
+
+      graph.should_receive(:create_edge).
+            with(node, other_node, edge_opts).
+            and_return(new_edge)
+
+      subject.should == new_edge
+    end
+  end
+
+  describe "#create_and_connect_to" do
+    let(:edge_opts)  {{ :type => GEXF::Edge::DIRECTED }}
+    let(:node_attrs) {{ :label => 'other node'}}
+    let(:new_node)   { mock('new_node') }
+
+    subject { node.create_and_connect_to(node_attrs, edge_opts) }
+
+    it "creates the node, adds it to nodes collection, and returns it" do
+      graph.should_receive(:create_node).with(node_attrs).and_return(new_node)
+      collection.should_receive(:<<).with(new_node)
+      graph.should_receive(:create_edge).with(node, new_node, edge_opts)
+
+      subject.should == new_node
+    end
+  end
+
+  describe "#connections" do
+    subject { node.connections }
+
+    it "delegates to graph.edges[node.id]" do
+      edges.should_receive(:[]).with(node.id)
+      subject
+    end
+  end
+end