waves-stable 0.7.7

data/verify/layers/data_mapper/association_verify.rb

@@ -0,0 +1,87 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__), "..", "helpers")
+
+begin
+  require 'layers/orm/data_mapper'
+  require 'flexmock'
+
+  module DMApplication
+    include Waves::Foundations::Default
+    include Waves::Layers::ORM::DataMapper
+  end
+
+  DMA = DMApplication
+  DMAMapping = DMA::Configurations::Mapping
+  DMApplication::Configurations::Default
+
+  module DMA ; include Waves::Foundations::Simple ; end
+  Waves << DMA
+  Waves::Console.load( :mode => :development )
+
+  module DMApplication
+    module Configurations
+      class Development < Default
+        database :database => 'sqlite3::memory'
+      end
+    end
+  end
+
+  module Bacon
+    class Context
+      include FlexMock::ArgumentTypes
+      include FlexMock::MockContainer
+    end
+  end
+
+  describe "DataMapper Associations" do
+  
+    before do
+      @adapter = FlexMock::DefaultFrameworkAdapter.new
+    end
+
+    after do
+      flexmock_verify
+    end
+
+    it 'should add before and after filters that push a new repo' do
+      filters = DMAMapping.send :filters
+      filters.should.not == nil
+      filters[:before][0][0][:path].should == true
+      filters[:always][0][0][:path].should == true
+      before_size = ::DataMapper::Repository.context.size
+      filters[:before][0][1].call
+      after_size = ::DataMapper::Repository.context.size
+      (after_size - before_size).should == 1
+      filters[:always][0][1].call
+      end_size = ::DataMapper::Repository.context.size
+      (end_size - after_size).should == -1
+    end
+
+    it 'should add before and after filters that push a new repo with flexmock' do
+      mock_context = flexmock("context")
+      flexmock(::DataMapper::Repository, :context => mock_context)
+      mock_context.should_receive(:push).once
+      mock_context.should_receive(:pop).once
+
+      filters = DMAMapping.send :filters
+      filters[:before][0][1].call
+      filters[:always][0][1].call
+    end
+  
+    it 'should initialize the database adapater' do
+      DMA.database.class.should.not == nil
+      DMA.database.class.should == ::DataMapper::Adapters::Sqlite3Adapter
+    end
+
+    it 'It should load models' do
+      # pending
+    end
+
+  end
+rescue LoadError => e
+  describe "DataMapper Associations" do
+    it 'should be able to load dm-core' do
+      puts "\nDatamapper associations specs not run! Could not load dm-core: #{e}\n"
+    end
+  end
+end

data/verify/layers/default_errors.rb

@@ -0,0 +1,29 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__) , "helpers")
+
+module DefaultErrorsApp
+  include Waves::Foundations::Simple
+  include Waves::Layers::DefaultErrors
+  module Views
+    class Errors
+      include Waves::Views::Mixin
+      def not_found_404(arg)
+        "View-based 404"
+      end
+    end
+  end
+  stub!(:views).and_return(Views)
+end
+
+# Waves << DefaultErrorsApp
+Waves::Console.load( :mode => :development )
+
+
+describe "An application which includes the DefaultErrors layer" do
+  
+  it "registers a view-based handler for NotFound errors" do    
+    r = get('/bogus')
+    r.body.should == "View-based 404"
+  end
+  
+end

data/verify/layers/helpers.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__) , "..", "helpers")

data/verify/layers/migration.rb

@@ -0,0 +1,33 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__) , "helpers")
+require 'layers/orm/migration'
+
+ORM = Waves::Layers::ORM
+
+Dir.chdir("#{File.dirname(__FILE__)}/../../samples/blog") do
+
+  describe "Waves::Layers::ORM migration helpers" do
+  
+    it "defines a standard migration location" do
+      ORM.migration_directory.should == "schema/migrations"
+    end
+  
+    it "supplies a list of all migration files found in the standard location" do
+      ORM.migration_files.should == ["schema/migrations/001_initial_schema.rb", "schema/migrations/002_add_comments.rb"]
+    end
+  
+    it "detects the highest-numbered existing migration file" do
+      ORM.latest_migration_version.should == 2
+    end
+  
+    it "determines the number of the next migration to be created" do
+      ORM.next_migration_version.should == 3
+    end
+    
+    it "generates the path for the next migration with a given name" do
+      ORM.migration_destination("blink").should == "schema/migrations/003_blink.rb"
+    end
+  
+  end
+
+end

data/verify/layers/sequel/model.rb

@@ -0,0 +1,41 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__) , "..", "helpers")
+require 'layers/orm/sequel'
+
+module TestApplication
+  include AutoCode
+  module Configurations
+    class Development
+      stub!(:database).and_return(:adapter => 'sqlite',
+				  :database => "#{File.dirname(__FILE__)}test.db")
+    end
+  end
+  stub!(:config).and_return(Configurations::Development)
+  include Waves::Layers::ORM::Sequel
+end
+
+Waves << TestApplication
+# Waves::Console.load( :mode => :development )
+TA = TestApplication
+
+describe "An application module which includes the Sequel ORM layer" do
+  
+  wrap { rm_if_exist 'test.db' }
+    
+  it "auto_creates models that inherit from Sequel::Model" do
+    TA::Models::Default.superclass.should == Sequel::Model
+    TA::Models::Thingy.superclass.should == TA::Models::Default
+  end
+  
+  it "sets the dataset to use the snake_case of the class name as the table name" do
+    TA::Models::Thingy.dataset.send(:to_table_reference).should =~ /SELECT.+FROM.+thingies+/
+  end
+  
+  it "provides an accessor for database" do
+    TA.should.respond_to :database
+  end
+  
+end
+
+# Waves.instance_variable_set(:@application, nil)
+# raise Waves.application.inspect

data/verify/mapping/always.rb

@@ -0,0 +1,19 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__), "helpers")
+::TEST_VALUE = 'foo'
+
+specification "A developer can ensure" do
+
+  before do
+    mapping.clear
+    path('/' ) { raise RuntimeError.new('bar') }
+    always( true ) { Waves.been_there }
+  end
+
+  specify 'processing is guaranteed regardless of what happens in an action' do
+    Waves.should.receive(:been_there)
+    lambda { get('/') }.should.raise RuntimeError
+  end
+
+end
+

data/verify/mapping/filters.rb

@@ -0,0 +1,65 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__), "helpers")
+
+describe "A developer can map requests to filters." do
+
+  before do
+    mapping.clear
+    handle(Waves::Dispatchers::NotFoundError) { response.status = 404}
+    mapping.before( :path => '/filters', :method => :post ) { request.response.write('Before post:') }
+    mapping.before( :path => '/filters' ) { request.response.write('Before:') }
+    mapping.wrap( :path => '/filters', :method => :post ) { request.response.write(':Wrap post:') }
+    mapping.wrap( :path => '/filters' ) { request.response.write(':Wrap:') }
+    mapping.path( '/filters' ) { 'During' }
+    mapping.after( :path => '/filters', :method => :post ) { request.response.write('After post:') }
+    mapping.after( :path => '/filters' ) { request.response.write(':After') }
+
+    regexp = %r{^/filters/(\w+)$}
+
+    mapping.before( :path => regexp ) { |filtername| request.response.write("Before #{filtername}:") }
+    mapping.wrap( :path => regexp ) { |filtername| request.response.write(":Wrap #{filtername}:") }
+    mapping.path( regexp ) { 'During' }
+    mapping.after( :path => regexp ) { |filtername| request.response.write(":After #{filtername}") }
+
+    mapping.before( :path => 'filters_with_no_map' ) { request.response.write("Before") }
+    mapping.wrap( :path => 'filters_with_no_map' ) { request.response.write("Wrap") }
+    mapping.after( :path => 'filters_with_no_map' ) { request.response.write("After") }
+
+    mapping.before('/pathstring') { request.response.write("Before pathstring") }
+    mapping.wrap('/pathstring') { request.response.write("Wrap pathstring") }
+    mapping.path('/pathstring') { "During pathstring" }
+    mapping.after('/pathstring') { request.response.write("After pathstring") }
+
+    mapping.before(%r{^/pathregexp$}) { request.response.write("Before pathregexp") }
+    mapping.wrap(%r{^/pathregexp$}) { request.response.write("Wrap pathregexp") }
+    mapping.path(%r{^/pathregexp$}) { "During pathregexp" }
+    mapping.after(%r{^/pathregexp$}) { request.response.write("After pathregexp") }
+
+    mapping.before('/pathstring/name', :method => :post) { request.response.write("Before pathstring post") }
+    mapping.wrap('/pathstring/name', :method => :post) { request.response.write("Wrap pathstring post") }
+    mapping.path('/pathstring/name', :method => :post) { "During pathstring post" }
+    mapping.after('/pathstring/name', :method => :post) { request.response.write("After pathstring post") }
+
+    mapping.before(%r{^/pathregexp/name$}, :method => :post) { request.response.write("Before pathregexp post") }
+    mapping.wrap(%r{^/pathregexp/name$}, :method => :post) { request.response.write("Wrap pathregexp post") }
+    mapping.path(%r{^/pathregexp/name$}, :method => :post) { "During pathregexp post" }
+    mapping.after(%r{^/pathregexp/name$}, :method => :post) { request.response.write("After pathregexp post") }
+  end
+
+  it "Map a path to a 'before', 'after' and 'wrap' filters." do
+    get('/filters').body.should == 'Before::Wrap:During:Wrap::After'
+  end
+
+  it "Map a POST to a path to a 'before', 'after' and 'wrap' filters" do
+    post('/filters').body.should == 'Before post:Before::Wrap post::Wrap:During:Wrap post::Wrap:After post::After'
+  end
+
+  it "The 'before', 'after' and 'wrap' filters accept a regular expression and can extract parameters from the request path" do
+    get('/filters/xyz').body.should == 'Before xyz::Wrap xyz:During:Wrap xyz::After xyz'
+  end
+
+  it "When having 'before', 'after' and 'wrap' filters but no corresponding map action this results in a 404" do
+    get('/filters_with_no_map').status.should == 404
+  end
+  
+end

data/verify/mapping/handle.rb

@@ -0,0 +1,24 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__), "helpers")
+
+specification "A developer can register exception handlers" do
+
+  before do
+    mapping.clear
+    mapping.handle(Waves::Dispatchers::NotFoundError) do
+       response.status = 404; response.body = "404 Not Found"
+    end
+    mapping.handle(Waves::Dispatchers::NotFoundError) do
+      response.status = 404; response.body = "Something Different"
+    end
+  end
+
+  specify 'The minimal 404 handler in SimpleErrors' do
+
+    r = get('/')
+    r.status.should == 404
+    r.body.should == '404 Not Found'
+  end
+
+
+end

data/verify/mapping/helpers.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__) , "..", "helpers")
+
+# define basic app for use in testing
+# before methods may add to it using helper methods
+module MappingApp ; include Waves::Foundations::Simple ; end
+Waves << MappingApp
+Waves::Console.load( :mode => :development )

data/verify/mapping/matches.rb

@@ -0,0 +1,27 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__), "helpers")
+
+specification "A developer can extract parameters from a request path or URL." do
+
+  before do
+    mapping.clear
+
+    path %r{/param/(\w+)} do |value|
+      "You asked for: #{value}."
+    end
+
+    url %r{http://localhost:(\d+)/port} do |port|
+      port
+    end
+
+  end
+
+  specify 'Extract a parameter via a regexp match of the path.' do
+    get('/param/elephant').body.should == 'You asked for: elephant.'
+  end
+
+  specify 'Extract a parameter via a regexp match of the URL.' do
+    get('http://localhost:3000/port').body.should == '3000'
+  end
+
+end

data/verify/mapping/named.rb

@@ -0,0 +1,29 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__), "helpers")
+
+specification "A developer can register named mappings" do
+
+  # before do
+  #   mapping.clear
+  #   resource = /([\w\-]+)/
+  #   name = /([\w\-\_\.\+\@]+)/
+  #   path [resource, name], 
+  #     :generator => generator(:show) { |resource,name| "/#{resource}/#{name}" } do 
+  #       "Works"
+  #     end
+  # end
+  # 
+  # specify "accessible via Waves.mapping.named" do
+  #   
+  #   Waves.mapping.named.show("foo", "bar").should == "/foo/bar"
+  #   
+  # end
+  # 
+  # specify "accessible via Application.paths" do
+  #   
+  #   Test.paths.show("foo", "bar").should == "/foo/bar"
+  #   
+  # end
+
+
+end

data/verify/mapping/options.rb

@@ -0,0 +1,17 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__), "helpers")
+
+specification "A developer can map requests with options." do
+
+  before do
+    mapping.clear
+    path('/', :remote_addr => "10.10.10.10" ) { 'This request is from 10.10.10.10' }
+    path('/', :remote_addr => "127.0.0.1" ) { 'This request is from 127.0.0.1' }
+  end
+
+  specify 'Map the path of a GET request to a lambda.' do
+    get('/').body.should == 'This request is from 127.0.0.1'
+  end
+
+end
+

data/verify/mapping/path.rb

@@ -0,0 +1,40 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__), "helpers")
+
+specification "A developer can map requests using the request path." do
+
+  before do
+    mapping.clear
+    path('/', :method => :post ) { 'This is a simple post rule.' }
+    path('/', :method => :put ) { 'This is a simple put rule.' }
+    path('/', :method => :delete ) { 'This is a simple delete rule.' }
+    path('/', :method => :get) { 'This is a simple get rule.' }
+    path('/foo') { "The server says, 'bar!'" }
+  end
+
+  specify 'Map the path of a GET request to a lambda.' do
+    get('/').body.should == 'This is a simple get rule.'
+  end
+
+  specify 'Map the path of a POST request to a lambda.' do
+    post('/').body.should == 'This is a simple post rule.'
+  end
+
+  specify 'Map the path of a PUT request to a lambda.' do
+    put('/').body.should == 'This is a simple put rule.'
+  end
+
+  specify 'Map the path of a DELETE request to a lambda.' do
+    delete('/').body.should == 'This is a simple delete rule.'
+  end
+
+  specify 'When method is not explicitely set in a mapping it accepts all methods' do
+    get( '/foo' ).body.should == "The server says, 'bar!'"
+    post( '/foo' ).body.should == "The server says, 'bar!'"
+    put( '/foo' ).body.should == "The server says, 'bar!'"
+    delete( '/foo' ).body.should == "The server says, 'bar!'"
+  end
+
+
+end
+

data/verify/mapping/response_proxy.rb

@@ -0,0 +1,50 @@
+# require 'test_helper' because RubyMate needs help
+require File.join(File.dirname(__FILE__), "helpers")
+
+# Note: you have to define the resource classes using module_eval here, because otherwise
+# the auto_create code never gets triggered in the application.
+
+module MappingApp
+  include Waves::Layers::MVC
+end
+
+MappingApp::Controllers.module_eval do
+  class Animal
+    include Waves::Controllers::Mixin
+    def cow() 'Moo!' end
+  end
+end
+
+MappingApp::Views.module_eval do
+  class Animal
+    include Waves::Views::Mixin
+    def say( says ) "This animal says: '#{says}'" end
+  end
+end
+
+specification "A developer may succinctly define a resource-based controller-view chain." do
+
+  before do
+    mapping.clear
+    path('/cow' ) do
+      resource( :animal ) { controller { cow } | view { | says | say( says ) } }
+    end
+    
+    path('/onager') do
+      resource( "cow" ) do
+        controller { redirect model_name }.call
+      end
+    end
+  end
+
+  specify 'Pipe output of controller to view within a resource context.' do
+    get('/cow').body.should == "This animal says: 'Moo!'"
+  end
+  
+  specify "Redirect from within controller" do
+    get('/onager').status.should == 302
+  end
+
+
+end
+