qcourses 0.1.2

data/spec/qcourses/controllers/registrations_controller_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'capybara/rspec'
+
+module Qcourses 
+
+  describe RegistrationsController, :type => :request do
+    let(:app) { Capybara.app = RegistrationsController } 
+    let(:event) { Rubory.create :event }
+
+    describe 'get new' do
+      def url(id)
+        "/registrations/new/#{id}"
+      end
+
+      it "should render a form" do
+        get url(event.id)
+        last_response.should be_ok
+        last_body.should have_selector("form#registrations[@method='post'][@action='/registrations/#{event.id}']")
+      end
+
+      it "should return a 404 when event is not available" do
+        get url(event.id + 33334)
+        last_response.should be_not_found
+      end
+
+      it "should return a 404 when event is in the past" do
+        event.update :from => Date.today
+        get url(event.id)
+        last_response.should be_not_found
+      end
+
+    end
+
+    describe 'post registration' do
+      def url(id)
+        "/registrations/#{id}"
+      end
+
+      let(:participants) { [valid_participant] }
+      let!(:valid_company) { Rubory.attributes_for :company }
+      let!(:valid_participant) { Rubory.attributes_for :employee }
+      let(:valid_registration) { { employee: participants, company: valid_company} }
+
+      context "on valid attributes" do
+        it "redirects to thank you" do
+          post url(event.id), valid_registration
+          last_response.should be_redirect
+          follow_redirect!
+          last_body.should have_selector(".thanks")
+        end
+        it "creates a registration" do
+          expect { post url(event.id), valid_registration }.to change { Registration.count }.by(1)
+        end
+        it "creates a company" do
+          expect { post url(event.id), valid_registration }.to change { Company.count }.by(1)
+        end
+        it "creates an employee" do
+          expect { post url(event.id), valid_registration }.to change { Employee.count }.by(1)
+        end
+        context "with more employees" do
+          let!(:another_participant) { Rubory.attributes_for :employee }
+          let(:participants) { [valid_participant, another_participant] }
+          it "creates more registrations" do
+            expect { post url(event.id), valid_registration }.to change { Registration.count }.by(2)
+          end
+          it "creates a company" do
+            expect { post url(event.id), valid_registration }.to change { Company.count }.by(1)
+          end
+          it "creates more employees" do
+            expect { post url(event.id), valid_registration }.to change { Employee.count }.by(2)
+          end
+        end
+      end
+      context "problems with event" do
+        it "should return a 404 when event is not available" do
+          post url(event.id + 33334)
+          last_response.should be_not_found
+        end
+
+        it "should return a 404 when event is in the past" do
+          event.update :from => Date.today
+          post url(event.id)
+          last_response.should be_not_found
+        end
+      end
+      context "problems with attributes" do
+        context "participant invalid" do
+          it "shows error on attribute" do
+            valid_participant[:email] = ''
+            post url(event.id), valid_registration
+            last_response.should be_ok
+            last_body.should have_selector("form input.error[name='employee[][email]']")
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/spec/qcourses/models/course_repository_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+module Qcourses
+  class StubCourseFileOpener
+    def initialize(files = {})
+      @files=files
+      @files.default = ''
+    end
+    def define_file(filename, content)
+      @files[filename] = content
+    end
+    def open(name, &block)
+      StringIO.open(@files[name], &block)
+    end
+  end
+
+  class StubDirectory
+   
+    def initialize
+      @results = {}
+      @results.default = []
+    end
+
+    def glob(pattern)
+      @results[pattern]
+    end
+
+    def pattern(pattern, options = {returns: []})
+      @results[pattern] = options[:returns]
+    end
+  end
+
+  describe 'CourseRepository' do
+    let(:directory) { StubDirectory.new  }
+    let(:file_opener) { StubCourseFileOpener.new('first_course.mdown' =>  "Name: first course",
+                                                 'second_course.mdown' =>  "Name: second course") }
+    let(:repository) { CourseRepository.new(directory, file_opener) }
+    let(:first_course) { repository.all.first }
+
+    describe 'class methods' do
+      it "can't be used when not configured yet" do
+        expect { CourseRepository.all }.to raise_exception CourseRepository::Error
+      end
+    end
+
+    describe 'all' do
+      context "detecting course files" do 
+        it "returns a course for all the **/courses/*.mdown files" do
+          directory.pattern("**/courses/*.mdown", returns: ['first_course.mdown', 'second_course.mdown'])
+
+          repository.all.should == [ Course.new(identification: 'first_course', name: 'first course'),
+                                     Course.new(identification: 'second_course', name: 'second_course') ]
+        end
+
+        it "returns a course for all the **/cursussen/*.mdown files " do
+          directory.pattern("**/cursussen/*.mdown", returns: ['first_course.mdown', 'second_course.mdown'])
+
+          repository.all.should == [ Course.new(identification: 'first_course', name: 'first course'),
+                                     Course.new(identification: 'second_course', name: 'second_course') ]
+        end
+        it "ignores duplication in courses" do
+          directory.pattern("**/courses/*.mdown", returns: ['first_course.mdown'])
+          directory.pattern("**/cursussen/*.mdown", returns: ['first_course.mdown'])
+
+          repository.all.should == [ Course.new(identification: 'first_course', name: 'first course')]
+        end
+
+        it "uses just the actual filenames as the course name - not the complete path" do
+          directory.pattern("**/cursussen/*.mdown", returns: ['en/courses/first_course.mdown'])
+          file_opener.define_file('en/courses/first_course.mdown', "Name: first course")
+
+          first_course.should == Course.new(identification: 'first_course', name: 'first course')
+        end
+
+        it "skips index files" do
+          directory.pattern("**/cursussen/*.mdown", returns: ['en/courses/index.mdown'])
+          file_opener.define_file('en/courses/index.mdown', "Name: first course")
+
+          repository.all.should == []
+        end
+      end
+
+      context "parsing the course" do
+        before do
+          directory.pattern("**/cursussen/*.mdown", returns: ['first_course.mdown'])
+        end
+        def course_file_contains(content)
+          file_opener.define_file('first_course.mdown', content)
+        end
+        it "accepts more headers after name" do
+          course_file_contains(%Q{Name: first course
+                                  Category: training})
+          first_course.name.should == 'first course'
+        end
+        it "accepts more headers before name" do
+          course_file_contains(%Q{Category: training
+                                  Name: first course })
+          first_course.name.should == 'first course'
+        end
+        it "ignores headers after first empty line" do
+          course_file_contains(%Q{Category: training
+
+                                  Name: first course })
+          first_course.name.should == 'first_course'
+        end
+        it "ignores lines after first line that does not contain colon" do
+          course_file_contains(%Q{Category training
+                                  Name: first course })
+          first_course.name.should == 'first_course'
+        end
+        context "name" do
+          it "uses identification as the name if the name is not defined" do
+            course_file_contains('')
+            first_course.name.should == 'first_course'
+          end
+          it "reads the name from the Name header" do
+            course_file_contains('Name: first course')
+            first_course.name.should == 'first course'
+          end
+          it "accepts colon in name" do
+            course_file_contains('Name: first: course')
+            first_course.name.should == 'first: course'
+          end
+        end
+        context "subtitle" do
+          it "is empty if the subtitle is not defined" do
+            course_file_contains('')
+            first_course.subtitle.should == ''
+          end
+          it "reads the subtitle from the Subtitle header" do
+            course_file_contains('Subtitle: learn stuff!')
+            first_course.subtitle.should == 'learn stuff!'
+          end
+        end
+      end
+    end
+    describe "find(course_identification)" do
+      it "returns the associated course" do
+        repository.find('first_course').should == first_course
+      end
+      it "returns nil if course does not exist" do
+        repository.find('non-existing').should be_nil
+      end
+    end
+  end
+
+end

data/spec/qcourses/models/event_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module Qcourses
+  describe Event do
+    
+
+    describe "storing events" do
+      subject { Event.new valid_attributes }
+      context "location as a string" do 
+        let(:valid_attributes) { { course_id: 'agile_engineering', from: "10-04-2012", to: "13-04-2012", location: "Tilburg"}  }
+
+        it "can be stored and loaded" do
+          subject.save
+          reloaded = Event[subject.id]
+          reloaded.should == subject 
+        end
+
+        it "should fail on empty location" do 
+          subject.should reject_values("").for(:location)
+        end
+        it { should accept_values("2012-04-01", "10-10-2012").for(:from) }
+        it { should accept_values("2012-04-01", "10-10-2012").for(:to) }
+      end
+    end
+
+    describe "attributes" do
+
+      let(:subject) {Event.new(course_id: 'ae', from: "10-04-2012", to: "12-04-2012") }
+      its(:from) { should be_a(Time) }
+      its(:from) { should == Time.parse("10-04-2012") }
+      its(:to) { should be_a(Time) }
+
+
+      describe "from course" do
+        let(:course_repository) { CourseRepository.in_memory }
+        let!(:course) { course_repository.create_course :identification => 'ae', :name => "AE", :subtitle => 'learn ae' }
+        its(:name) { should == course.name }
+        its(:subtitle) { should == course.subtitle }
+
+        context 'when course not available' do
+          before { subject.course_id = 'removed_id' }
+          its(:name) { should == 'removed course (removed_id)' }
+          its(:subtitle) { should == '' }
+        end
+      end
+
+      describe 'location' do
+        it "is converted to a location object" do
+          subject.location = "Tilburg" 
+          subject.location.should be_a(Location) 
+          subject.location.name.should == 'Tilburg'
+        end
+
+        it "_name attribute delegates to location or is unknown" do
+          subject.location_name.should == 'unknown'
+          subject.location = "Tilburg"
+          subject.location_name.should == subject.location.name 
+        end
+
+        context "with same name exists" do
+          let!(:existing_location) { Location.create(name: "Tilburg") }
+          it "existing location is used when available" do
+            subject.location = "Tilburg" 
+            subject.location.should == existing_location
+          end
+          it "existing location is located case insensitive" do
+            subject.location = "tilburG" 
+            subject.location.should == existing_location
+          end
+        end
+      end
+    end
+  end
+end

data/spec/qcourses/models/location_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Qcourses
+  describe Location do
+    describe 'storing locations' do
+      subject { Location.new valid_attributes }
+      let(:valid_attributes) {{name: 'Qwan Tilburg', address: "Gondelstraat", postal_code: "2323 AA", city: "Tilburg", url:"/contact" }}
+
+      it "should be able to save an read back" do
+        subject.save
+        read_back = Location[subject.id]
+        read_back.should == subject
+      end
+
+      it {should reject_values(nil, "").for(:name)} 
+      
+    end
+  end
+end

data/spec/qcourses/models/registration_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Qcourses
+  describe Registration do
+    describe "saving" do
+      let(:employee) { Rubory.create :employee } 
+      let(:event) { Rubory.create :event }
+      let(:subject) {Registration.new(employee: employee, event: event)}
+
+      it "can be saved and read back" do
+        subject.save
+        reloaded = Registration[subject.id]
+        reloaded.should == subject
+      end
+
+      it { should reject_values(nil).for(:employee) }
+      it { should reject_values(nil).for(:event) }
+    end
+  end
+
+  describe Employee do
+    describe "saving" do
+      let(:subject) { Rubory.build :employee }
+      it "can be saved and read back" do
+        subject.save
+        reloaded = Employee[subject.id]
+        reloaded.should == subject
+      end
+
+      it { should reject_values(nil, "").for(:name) }
+      it { should reject_values(
+          nil, "",
+          "rob@", "@mo.nl", "123.nl", "123@nl", "aaa.123.nl", "aaa.123@nl").for(:email) }
+    end
+  end
+
+  describe Company do
+    describe "saving" do
+      let(:subject) { Rubory.build :company }
+      it "can be saved and read back" do
+        subject.save
+        reloaded = Company[subject.id]
+        reloaded.should == subject
+      end
+
+      it { should reject_values(nil, "").for(:name) }
+      it { should reject_values(nil, "").for(:contact_person) }
+      it { should reject_values(nil, "").for(:invoice_address) }
+      it { should reject_values(nil, "").for(:postal_code) }
+      it { should reject_values(nil, "").for(:city) }
+      it { should reject_values( nil, "", "rob@", "@mo.nl", "123.nl", "123@nl", "aaa.123.nl", "aaa.123@nl")
+                  .for(:contact_email) }
+    end
+  end
+end

data/spec/qcourses/renderers_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+module Qcourses
+  describe Renderers do
+    require 'sinatra'
+    let(:template_cache) { Tilt::Cache.new }
+    include Sinatra::Templates
+    include Renderers
+    let(:local_root) { spec_path 'files/local' }
+    let(:root) { spec_path "files/remote" }
+    let(:views) { 'views' }
+
+    after do 
+      delete_files('files')
+    end
+
+    def html_for(result)
+      Capybara.string(result)
+    end
+
+    describe 'haml' do
+      it "uses the local path if it exists" do
+        create_file('files/local/views/view.haml', '%h1 local view') 
+        html_for(haml(:'view')).should have_selector('h1', :text => 'local view')
+      end
+      it "uses the remote path if it exists" do
+        create_file('files/remote/views/view.haml', '%h1 remote view') 
+        html_for(haml(:'view')).should have_selector('h1', :text => 'remote view')
+      end
+      it "remote path overrides local if it exists" do
+        create_file('files/local/views/view.haml', '%h1 local view') 
+        create_file('files/remote/views/view.haml', '%h1 remote view') 
+        html_for(haml(:'view')).should have_selector('h1', :text => 'remote view')
+      end
+      it "uses the string if haml is a string" do
+        html_for(haml('%h1 inline view')).should have_selector('h1', :text => 'inline view')
+      end
+
+      context "with layout available locally" do
+        before do 
+          create_file('files/local/views/view.haml', '%h1 local view') 
+          create_file('files/local/views/layout.haml', "%h1 local layout \n=yield")
+        end
+        it "renders no layout when layout specified to be false" do
+          html_for(haml(:'view', layout: false )).should_not have_selector( 'h1', :text => 'local layout')
+        end
+        it "renders layout when layout specified to be true" do
+          html_for(haml(:'view', layout: true)).should have_selector( 'h1', :text => 'local layout')
+        end
+        it "renders layout when layout specified by name" do
+          html_for(haml(:'view', layout: :layout)).should have_selector( 'h1', :text => 'local layout')
+        end
+        it "complains about layout not to exist when layout is not available" do
+          expect { haml(:'view', layout: :admini) }.to raise_exception(Errno::ENOENT)
+        end
+      end
+
+      context "with layout available remotely" do
+        before do 
+          create_file('files/local/views/view.haml', '%h1 local view') 
+          create_file('files/remote/views/layout.haml', "%h1 remote layout \n=yield")
+        end
+        it "renders no layout when layout specified to be false" do
+          html_for(haml(:'view', layout: false )).should_not have_selector( 'h1', :text => 'remote layout')
+        end
+        it "renders layout when layout specified to be true" do
+          html_for(haml(:'view', layout: true )).should have_selector( 'h1', :text => 'remote layout')
+        end
+        it "renders layout when layout specified by name" do
+          html_for(haml(:'view', layout: :layout)).should have_selector( 'h1', :text => 'remote layout')
+        end
+        it "complains about layout not to exist when layout is not available" do
+          expect { haml(:'view', layout: :admin) }.to raise_exception(Errno::ENOENT)
+        end
+        it "falls back to local layout when remote does not exist" do
+          create_file('files/local/views/admin.haml', "%h1 local admin layout \n=yield")
+          html_for(haml(:'view', layout: :admin)).should have_selector( 'h1', :text => 'local admin layout')
+        end
+      end
+    end
+  end
+end

data/spec/qcourses/string_ex_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe String do
+  describe "underscore" do
+    it "underscores a camel cased string" do
+      "Event".underscore.should == "event"
+      "EventName".underscore.should == "event_name"
+      "EEEventName".underscore.should == "ee_event_name"
+    end
+  end
+end

data/spec/qcourses/view_helpers_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module Qcourses
+  describe ViewHelpers do
+    require 'sinatra'
+    let(:template_cache) { Tilt::Cache.new } 
+    include Sinatra::Templates
+    include ViewHelpers
+
+    describe 'human_period' do
+      let(:event) { Event.new(from: "30-11-2012", to: "02-12-2013") }
+      let(:subject) { human_period(event.from, event.to) }
+
+      it "formats both dates short with a hyphen inbetween" do
+        subject.should == "30/11/2012 - 2/12/2013"
+      end
+
+      context "when dates are in same year" do
+        before { event.to = "02-12-2012" }
+        it "formats both dates with a hyphen when dates are in different months" do
+          subject.should == '30/11 - 2/12 2012'
+        end
+
+        context "when dates are in same month" do
+          it "formats both dates with a hyphen" do
+            event.from = "1-12-2012"
+            subject.should == '1 - 2 December 2012'
+          end
+        end
+      end
+    end
+
+    describe "input_for" do
+      def html_for(result)
+        Capybara.string(result)
+      end
+      before do 
+        @employee = Employee.new :name => 'gijs' 
+        @employee.valid?
+      end
+      describe "on an existing object" do
+        it 'creates an input tag' do
+          html_for(input_for(:employee, :name)).should have_selector("input[type='text'][name='employee[name]'][value='gijs']")
+          html_for(input_for(@employee, :name)).should have_selector("input[type='text'][name='employee[name]'][value='gijs']")
+        end
+        it 'creates an an error class if attribute has error' do
+          result = html_for(input_for(:employee, :email))
+          result.should have_selector("input[type='text'][name='employee[email]'][class='error']")
+          result.should have_selector("span[class='error']", :text => @employee.errors.on(:email).first)
+        end
+        it 'can suppress error messagee if attribute has error' do
+          result = html_for(input_for(:employee, :email, :suppress_error_messages => true))
+          result.should have_selector("input[type='text'][name='employee[email]'][class='error']")
+          result.should_not have_selector("span[class='error']", :text => @employee.errors.on(:email).first)
+        end
+        it 'can have a class' do
+          html_for(input_for(:employee, :name, :class => 'short')).should have_selector("input[name='employee[name]'][class='short']")
+          html_for(input_for(:employee, :email, :class => 'short')).should have_selector("input[name='employee[email]'][class='error short']")
+        end
+      end
+      describe "on an array object" do
+        it "creates an input tag with an extra [] inthe name" do
+          html_for(input_for(:employee, :name, :array_element=>true)).should have_selector("input[type='text'][name='employee[][name]'][value='gijs']")
+        end
+      end
+    end
+    describe "text_field_for" do
+      def html_for(result)
+        Capybara.string(result)
+      end
+      before do 
+        @company = Company.new
+      end
+      describe "on an existing object" do
+        it 'creates a textarea tag' do
+          html_for(textarea_for(:company, :invoice_address)).should have_selector("textarea[name='company[invoice_address]']")
+          html_for(textarea_for(@company, :invoice_address)).should have_selector("textarea[name='company[invoice_address]']")
+        end
+        it "contains the value" do
+          @company.invoice_address = "Gondelstraat\nTilburg"
+          html_for(textarea_for(:company, :invoice_address)).should have_selector("textarea[name='company[invoice_address]']", :text=>@company.invoice_address)
+        end
+        it 'creates an an error class if attribute has error' do
+          @company.errors.add(:invoice_address, "wrong address")
+          html_for(textarea_for(:company, :invoice_address)).should have_selector("textarea[name='company[invoice_address]'][class='error']")
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+ENV['RACK_ENV'] = 'test'
+
+require 'rspec'
+require 'qcourses'
+require 'rack/test'
+require 'capybara'
+
+Qcourses.configure do |config| 
+  config.root = File.expand_path('..',File.dirname(__FILE__))
+end
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+class RSpec::Core::ExampleGroup
+  # Setting an around filter globally doesn't appear to work in 2.7 (and maybe other versions),
+  # so set one up for each subclass.
+  def self.inherited(subclass)
+    super
+    subclass.around do |example|
+      Qcourses::CourseRepository.destroy
+      Sequel::Model.db.transaction(:rollback=>:always){example.call}
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Rack::Test::Methods
+  config.include TestFiles
+  config.filter_run_excluding :broken => true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

data/spec/support/factories.rb

@@ -0,0 +1,24 @@
+require 'factories'
+require 'qcourses/date_ex'
+Rubory.use_default_module('Qcourses')
+
+Rubory.define(:company) do
+  name { |n| "company_#{n}" }
+  contact_person "some contact"
+  contact_email { |n| "contact_#{n}@email.com" }
+  invoice_address "some address"
+  postal_code "1234 AA"
+  city "Amsterdam"
+end
+
+Rubory.define(:employee) do
+  name "some employee"
+  email { |n| "email_#{n}@qwan.it" }
+  associate :company
+end
+
+Rubory.define(:event) do
+  from { Date.tomorrow }
+  to { Date.tomorrow.tomorrow }
+  location "Tilburg"
+end