crudtree 0.1.2

data/test/helper/suite/lib/generator.rb

@@ -0,0 +1,44 @@
+class Model0
+  def id
+    0
+  end
+end
+class Model1
+end
+class Model2
+  def id
+    2
+  end
+  def model0
+    Model0.new
+  end
+end
+class Klass0
+end
+class Klass1
+end
+class Klass2
+end
+
+class Mod0
+  def id
+    0
+  end
+end
+class Mod1
+  def id
+    1
+  end
+  def mod0
+    Mod0.new
+  end
+end
+class Mod2
+  def id
+    2
+  end
+  def initialize(parent = Mod0)
+    instance_variable_set("@#{parent.to_s.downcase}", parent.new)
+  end
+  attr_accessor :mod0, :mod1, :mod2
+end

data/test/helper/suite/lib/integration.rb

@@ -0,0 +1,9 @@
+module Usher
+  module Interface
+    def self.class_for(interface)
+      Rack
+    end
+    class Rack
+    end
+  end
+end

data/test/helper/suite/lib/interface/blackbox.rb

@@ -0,0 +1,36 @@
+def results_in(path, klass, call, params)
+  klass.expects(:dispatcher).with(call).returns(:yeah!)
+  to_mock = mock('to')
+  to_mock.expects(:to).with(:yeah!).returns(true)
+  Usher::Interface.class_for(:rack).any_instance.expects(:path).with(path, params).returns(to_mock)
+end
+
+module Usher; module Interface; class Rack;
+  include CRUDtree::Interface::Usher::Rack
+  def initialize(app = nil, options = nil, &block) 
+    instance_eval(&block) if block
+  end
+end; end; end
+class TestObj0; end
+class TestObj1; end
+class TestObj2; end
+
+def default_routes(number=0)
+  default_route(TestObj0)
+  default_route(TestObj1, "/testobj0/:id") if number > 0
+  default_route(TestObj2, "/testobj0/:id/testobj1/:id") if number > 1
+end
+
+def default_route(klass, pre_path=nil)
+  results_in("#{pre_path}/#{klass.to_s.downcase}", klass, :index, :conditions => {:request_method => "GET"})
+  results_in("#{pre_path}/#{klass.to_s.downcase}/:id", klass, :show, :conditions => {:request_method => "GET"})
+end
+module Usher
+  module Interface
+    def self.class_for(interface)
+      Rack
+    end
+    class Rack
+    end
+  end
+end

data/test/setup.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.expand_path("#{__FILE__}/../../lib")) # Add PROJECT/lib to $LOAD_PATH
+require 'crudtree'
+require 'baretest/mocha'
+include CRUDtree
+include Mocha::API
+require 'ruby-debug'

data/test/suite/lib/generator.rb

@@ -0,0 +1,244 @@
+require 'ostruct'
+BareTest.suite do
+
+  suite "CRUDtree" do
+
+    suite "Generator" do
+
+      suite "#generate_url_from_node" do
+
+        setup :node, "a simple node" do
+          @node = Node.new(nil, :paths => ["foo"], klass: Object, model: Object ){:foo}
+          @path = "/foo/23"
+          @identifiers = [23]
+        end
+
+        setup :node, "a node with multiple parents" do
+          master = Master.new
+          master.node(klass: Object, model: Object, paths: ["foo"]) do
+            node(klass: Object, model: Object, paths: ["bar"]) do
+              node(klass: Object, model: Object, paths: ["baz"]) {:foo}
+            end
+          end
+          @node = master.nodes.first.nodes.first.nodes.first
+          @path = "/foo/1/bar/2/baz/3"
+          @identifiers = [1,2,3]
+        end
+
+        assert ":node goes to the right path" do
+          equal(@path, CRUDtree::Generator.allocate.send(:generate_url_from_node, @node, @identifiers))
+        end
+
+      end
+
+      suite "#model_to_node" do
+
+        setup do
+          class TestObj0; end
+          class TestObj1; end
+        end
+
+        setup :master, "a simple master" do
+          master = CRUDtree::Master.new
+          master.node(klass: Object, model: ::TestObj0) {:foo}
+          @generator = CRUDtree::Generator.new(master)
+          @node = master.nodes.first
+          @model = ::TestObj0
+        end
+
+        setup :master, "a complex master" do
+          master = CRUDtree::Master.new
+          master.node(klass: Object, model: ::TestObj1){
+            node(klass: Object, model: ::TestObj0){:foo}
+          }
+          @generator = CRUDtree::Generator.new(master)
+          @node = master.nodes.first.nodes.first
+          @model = ::TestObj0
+        end
+
+        setup :master, "a master with duplicate models" do
+          master = CRUDtree::Master.new
+          master.node(klass: Object, model: TestObj1){
+            node(klass: Object, model: ::TestObj0){:foo}
+            node(klass: Object, model: ::TestObj0){:foo}
+          }
+          @generator = CRUDtree::Generator.new(master)
+          @node = master.nodes.first.nodes
+          @model = ::TestObj0
+        end
+
+        assert "The right model is found on :master." do
+          equal(@node, @generator.instance_variable_get(:@model_to_node)[@model])
+        end
+
+      end
+
+      suite "node finding" do
+
+        suite "without duplicates" do
+
+          setup do
+            @master = CRUDtree::Master.new
+          end
+
+          setup :master, "a simple master" do
+            @node = @master.node(klass: Klass0, model: Model0){:foo}
+            @resource = Model0.new
+            @valid = [[Model0.new, @node, ["0"]]]
+            @invalid = [[Model2.new, @node], [Model1.new, @node]]
+          end
+
+          setup :master, "a complex master" do
+            @master.node(klass: Klass0, model: Model0) do
+              node(klass: Klass1, model: Model1){:foo}
+              node(klass: Klass2, model: Model2){:foo}
+            end
+            @node = @master.nodes.first.nodes.last
+            @resource = Model2.new
+            @valid = [[Model2.new, @node, ["0","2"]], [Model0.new, @master.nodes.first, ["0"]]]
+            @invalid = [[Model0.new, @node], [Model1.new, @node]]
+          end
+
+          assert "#identifiers_returns the corret identifiers with :master" do
+            generator = CRUDtree::Generator.new(@master)
+            @valid.all?{|model, node, ary| generator.send(:identifiers_to_node, model, node) == ary}
+          end
+
+          assert "#identifiers returns false invalid with :master" do
+            generator = CRUDtree::Generator.new(@master)
+            @invalid.all?{|model, node| ! generator.send(:identifiers_to_node, model, node)}
+          end
+
+          assert "#find_node gets the correct node from :master" do
+            same(@node, CRUDtree::Generator.new(@master).send(:find_node, @resource).first)
+          end
+
+        end
+
+        suite "with duplicates" do
+
+          setup do
+            @master = Master.new
+            @master.node(klass: Klass0, model: Mod0) do
+              node(klass: Klass1, model: Mod1){:foo}
+              node(klass: Klass2, model: Mod2) do
+                node(klass: Klass2, model: Mod2){:foo}
+              end
+            end
+            @generator = CRUDtree::Generator.new(@master)
+          end
+
+          setup :node, "nested node" do
+            @node = @master.nodes.first.nodes.last.nodes.first
+            @resource = Mod2.new(Mod2)
+            @identifier = %w(0 2 2)
+          end
+
+          setup :node, "first node" do
+            @node = @master.nodes.first.nodes.last
+            @resource = Mod2.new(Mod0)
+            @identifier = %w(0 2)
+          end
+
+          assert "#identifiers_to_node returns an Array of identifiers for the :node" do
+            equal(@identifier, @generator.send(:identifiers_to_node, @resource, @node))
+          end
+
+          assert "#find_node gets :node based on the model" do
+            same(@node, @generator.send(:find_node, @resource).first)
+          end
+
+        end
+
+      end
+
+      suite "#generate_from_sub" do
+
+        setup do
+          @foo = OpenStruct.new(:name => :foo, :path => "foo")
+          @bar = OpenStruct.new(:name => :bar, :path => "bar")
+        end
+
+        setup :names, "one name" do
+          @node = OpenStruct.new(:subs => [@foo, @bar])
+          @names = [:foo]
+          @path = "/foo"
+        end
+
+        setup :names, "stacked names" do
+          @node = OpenStruct.new(:subs => [OpenStruct.new(:subs => [@foo, @bar], :name => :foo, :path => "foo"), @bar])
+          @names = [:foo, :bar]
+          @path = "/foo/bar"
+        end
+
+        assert "generates the correct url from :names" do
+          url = ""
+          Generator.allocate.send(:generate_from_sub, @node, @names, url)
+          equal(@path, url)
+        end
+
+      end
+
+      suite "blackbox" do
+
+        setup do
+          @master = Master.new
+          @master.node(klass: Klass0, model: Mod0) do
+            collection(call: :new)
+            member(call: :delete)
+            node(klass: Klass1, model: Mod1){:foo}
+            node(klass: Klass2, model: Mod2) do
+              member(call: :edit)
+              collection(call: :post)
+              node(klass: Klass2, model: Mod2){:foo}
+            end
+          end
+          @generator = CRUDtree::Generator.new(@master)
+        end
+
+        setup :model, "model for the nested node" do
+          @resource = Mod2.new(Mod2)
+          @path = "/klass0/0/klass2/2/klass2/2"
+        end
+
+        setup :model, "model for the first node" do
+          @resource = Mod2.new(Mod0)
+          @path = "/klass0/0/klass2/2"
+        end
+
+        setup :model, "model for the simplest node" do
+          @resource = Mod0.new
+          @path = "/klass0/0"
+        end
+
+        setup :model, "collection on base node" do
+          @resource = [:klass0, :new]
+          @path = "/klass0/new"
+        end
+
+        setup :model, "member on base node" do
+          @resource = [:klass0, :delete]
+          @path = "/klass0/delete"
+        end
+
+        setup :model, "member on simple node" do
+          @resource = [Mod2.new, :edit]
+          @path = "/klass0/0/klass2/2/edit"
+        end
+
+        setup :model, "collection on simple node" do
+          @resource = [Mod2.new, :post]
+          @path = "/klass0/0/klass2/post"
+        end
+
+        assert "#generate with :model" do
+          equal(@path, @generator.generate(*@resource))
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/suite/lib/integration.rb

@@ -0,0 +1,33 @@
+require 'crudtree/interface/usher/rack'
+module Usher
+  module Interface
+    class Rack
+      def initialize(app = nil, options = nil, &blk)
+      end
+    end
+  end
+end
+
+BareTest.suite do
+
+  suite "CRUDtree" do
+
+    suite "integartion" do
+
+      suite "inclusion" do
+
+        setup do
+          CRUDtree::Interface.for(:usher_rack)
+        end
+
+        assert "the module gets included and the methods are avaible" do
+          Usher::Interface.class_for(:rack).new.respond_to? :node
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/suite/lib/interface/blackbox.rb

@@ -0,0 +1,132 @@
+BareTest.suite "CRUDtree" do
+
+  suite "blackbox" do
+
+    setup :tree, "a simple tree" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          collection(call: :index, rest: :get)
+        end
+      }
+      results_in("/testobj0/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      # default routes
+      default_routes
+    end
+
+     setup :tree, "a nested tree" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          node(model: Object, klass: TestObj1) do
+            member(call: :show, rest: :get)
+          end
+        end
+      }
+      results_in("/testobj0/:id/testobj1/:id/show", TestObj1, :show, :conditions => {:request_method => "GET"})
+      # default routes
+      default_routes(1)
+     end
+
+     setup :tree, "a twice nested tree" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          node(model: Object, klass: TestObj1) do
+            node(model: Object, klass: TestObj2) do
+              collection(call: :create, rest: :post)
+            end
+          end
+        end
+      }
+      results_in("/testobj0/:id/testobj1/:id/testobj2/create", TestObj2, :create, :conditions => {:request_method => "POST"})
+      # default routes
+      default_routes(2)
+     end
+
+     setup :tree, "a tree with some subnodes" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          collection(call: :index, rest: :get)
+          member(call: :show, rest: :get)
+          member(call: :update, path: "edit", rest: :put)
+        end
+      }
+      results_in("/testobj0/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/testobj0/:id/edit", TestObj0, :update, :conditions => {:request_method => "PUT"})
+      results_in("/testobj0/:id/show", TestObj0, :show, :conditions => {:request_method => "GET"})
+      # default routes
+      default_routes
+     end
+
+     setup :tree, "a nested tree with some subnodes" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          member(call: :show, rest: :get)
+          node(model: Object, klass: TestObj1) do
+            collection(call: :index, rest: :get)
+            member(call: :show, rest: :get)
+            member(call: :update, path: "edit", rest: :put)
+          end
+        end
+      }
+      results_in("/testobj0/:id/show", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/testobj0/:id/testobj1/index", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/testobj0/:id/testobj1/:id/show", TestObj1, :show, :conditions => {:request_method => "GET"})
+      results_in("/testobj0/:id/testobj1/:id/edit", TestObj1, :update, :conditions => {:request_method => "PUT"})
+      # default routes
+      default_routes(1)
+     end
+
+     setup :tree, "a tree with multiple paths" do
+      @block = proc {
+        node(model: Object, paths: ["test", "foo", "bar"], klass: TestObj0) do
+          collection(call: :index, rest: :get)
+        end
+      }
+      results_in("/test/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      # default routes
+      results_in("/test", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/test/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+     end
+
+     setup :tree, "a nested tree with multiple paths" do
+      @block = proc {
+        node(model: Object, paths: ["foo", "bar"], klass: TestObj0) do
+          collection(call: :index, rest: :get)
+          node(model: Object, paths: ["test", "baz"], klass: TestObj1) do
+            member(call: :edit, rest: :get)
+          end
+        end
+      }
+      results_in("/foo/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/test/:id/edit", TestObj1, :edit, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/test/:id/edit", TestObj1, :edit, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/baz/:id/edit", TestObj1, :edit, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/baz/:id/edit", TestObj1, :edit, :conditions => {:request_method => "GET"})
+      # default routes
+      results_in("/foo", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/test", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/test", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/baz", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/baz", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/test/:id", TestObj1, :show, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/test/:id", TestObj1, :show, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/baz/:id", TestObj1, :show, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/baz/:id", TestObj1, :show, :conditions => {:request_method => "GET"})
+     end
+
+    assert "compilation of :tree" do
+      Usher::Interface.class_for(:rack).new(&@block)
+    end
+
+  end
+
+end