cukedep 0.0.1

data/lib/macros4cuke.rb

@@ -0,0 +1,8 @@
+# File: macros4cuke.rb
+# This file acts as a jumping-off point for loading dependencies expected 
+# for a Macros4Cuke user.
+
+require_relative './macros4cuke/constants'
+require_relative './macros4cuke/macro-step-support'
+
+# End of file

data/sample/features/step_definitions/steps.rb

@@ -0,0 +1,105 @@
+# File: steps.rb
+# Step definitions for a sample Cucumber application
+
+Given(/^the catalogue is empty$/) do
+  $store.zap_catalogue!()
+end
+
+Given(/^I add the video "(.*?)" to the catalogue$/) do |a_title|
+  $store.add_video(a_title)
+end
+
+Then(/^I should see the video "(.*?)" as unknown$/) do |a_title|
+  $store.search_video(a_title).should be_nil
+end
+
+Then(/^I should see the video "(.*?)" as (available)$/) do |a_title, a_state|
+  found_video = $store.search_video(a_title)
+  found_video.state.should == a_state.to_sym
+end
+
+When(/^I remove the video "(.*?)"$/) do |a_title|
+  found_video = $store.search_video(a_title)
+  found_video.should_not be_nil
+  found_video.state.should == :available
+  $store.remove_video(found_video)
+end
+
+Given(/^there is no member yet$/) do
+  $store.send(:zap_members!)  # Why is this method seen as private?
+end
+
+Then(/^I should see member "(.*?)" as unknown$/) do |member_name|
+  $store.search_member(member_name).should be_nil
+end
+
+Then(/^I should see member "(.*?)" as registered$/) do |member_name|
+  $store.search_member(member_name).should_not be_nil
+  puts "Member #{member_name} is registered."
+end
+
+Given(/^I subscribe "(.*?)"$/) do |member_name|
+  $store.add_member(member_name)
+end
+
+
+Given(/^there is no registered user$/) do
+  $store.zap_users!
+end
+
+When(/^I enter the credentials "(.*?)"$/) do |credential|
+  @entered_credential = credential
+end
+
+Then(/^I should not be authorized$/) do
+  $store.search_user(@entered_credential).should be_nil
+  puts "Invalid user credential" 
+end
+
+When(/^I register my credentials "(.*?)"$/) do |credential|
+  $store.add_user(credential)
+end
+
+Then(/^I should see a welcome message$/) do
+  $store.search_user(@entered_credential).should_not be_nil  
+  puts "Welcome to the rental application."
+end
+
+
+When(/^I register the rental of "(.*?)" for "(.*?)"$/) do |a_title, member_name|
+  found_video = $store.search_video(a_title)
+  found_video.should_not be_nil
+  found_video.state.should == :available
+
+  member = $store.search_member(member_name)
+  member.should_not be_nil
+  $store.add_rental(found_video, member)
+  @confirm_rental = true
+end
+
+Then(/^I should see the rental confirmed$/) do
+  puts "Rental registered." if @confirm_rental
+  @confirm_rental = nil
+end
+
+Then(/^I should see the rental refused$/) do
+  puts "Rental refused." unless @confirm_rental
+end
+
+
+When(/^I register the return of "(.*?)" from "(.*?)"$/) do |a_title, member_name|
+  rental = $store.search_rental(a_title)
+  rental.should_not be_nil
+  rental.member.should == member_name
+  $store.close_rental(rental)
+  @confirm_return = true
+end
+
+Then(/^I should see the return confirmed$/) do
+  puts "Return registered." if @confirm_return
+  @confirm_return = nil
+end
+
+
+
+# End of file

data/sample/features/support/env.rb

@@ -0,0 +1,12 @@
+# File: env.rb
+
+require 'rspec/expectations'
+require_relative '../../model/model'
+
+AfterConfiguration do |_|
+  # Quick and dirty implementation: use a global variable
+  # as an entry point to the domain model.
+  $store = Sample::RentalStore.new
+end
+
+# End of file

data/sample/model/model.rb

@@ -0,0 +1,216 @@
+# File: model.rb
+
+require 'pp'
+require 'yaml'  # Rely on YAML for object persistence 
+
+
+# Module used as a namespace
+module Sample
+
+# Assumption: the store has one examplar only of a video title
+Video = Struct.new(
+  :title, # Title of the video (as an identifier)
+  :state  # Current state of the video
+)
+
+# A member of the video store, i.e. a person that is allowed 
+# to rent a video from the store.
+Member = Struct.new(
+  :name # As an identifier
+)
+
+# Association object between a Video and a Member.
+# In our sample model, no rental history is performed
+Rental = Struct.new(
+  :video, # Use the title of the rented video as key
+  :member   # Use the name of the Member as key
+)
+
+# The identification of a store rental employee
+# that is authorized to use the rental software.
+User = Struct.new(
+  :credential # user credential
+)
+
+# Simplistic domain model of a video rental store.
+class RentalStore
+  MyDir = File.dirname(__FILE__) + '/'
+  CatalogueFile = 'catalogue.yml'
+  MembersFile = 'members.yml'
+  RentalsFile = 'rentals.yml'
+  UsersFile = 'users.yml'
+
+
+  # The list of all videos owned by the store.
+  attr_reader(:catalogue)
+  
+  # The list of all Members
+  attr_reader(:members)
+  
+  # The list of all open-standing rentals
+  attr_reader(:rentals)
+  
+  # The list of application user (credentials)
+  attr_reader(:users)
+  
+  def initialize()
+    init_catalogue()
+    init_members()
+    init_rentals()
+    init_users()
+  end
+  
+
+  # Clear the catalogue (= make it empty).
+  def zap_catalogue!()
+    catalogue.clear()
+    save_catalogue()
+    zap_rentals!()
+  end
+  
+  def zap_members!()
+    members.clear()
+    save_members()
+    zap_rentals!()
+  end
+  
+  def zap_users!()
+    users.clear()
+    save_users()
+  end
+
+  # Search a Video object having the given title
+  def search_video(aTitle)
+    result = catalogue.find {|video| video.title.strip == aTitle.strip}
+    if result.nil?
+      msg = "Video with title '#{aTitle}' isn't in the catalogue."
+      $stderr.puts msg
+    end
+    
+    return result
+  end
+  
+  def remove_video(aVideo)
+    catalogue.delete(aVideo)
+    save_catalogue()
+  end
+
+  # Add a new video to the catalogue
+  def add_video(aTitle)
+    # Simplification: no check for title collision
+    catalogue << Video.new(aTitle, :available)
+    save_catalogue()
+  end
+  
+  def search_member(aName)
+    mb = members.find {|person| person.name.strip == aName.strip}
+    puts "No member with name #{aName}." if mb.nil?
+    
+    return mb
+  end
+
+  def add_member(aName)
+    # Simplification: no check for name collision
+    members << Member.new(aName)
+    save_members()
+  end
+  
+  def search_user(aCredential)
+    users.find {|user| user.credential.strip == aCredential.strip}
+  end
+  
+  def add_user(aCredential)
+    # Simplification: no check for credential collision
+    users << User.new(aCredential)
+    save_users()
+  end
+  
+  def search_rental(aTitle)
+    rentals.find {|r| r.video.strip == aTitle.strip}
+  end
+  
+  def add_rental(aVideo, aMember)
+    rentals << Rental.new(aVideo.title, aMember.name)
+    aVideo.state = :rented
+    save_rentals
+  end
+  
+  def close_rental(aRental)
+    rentals.delete(aRental)
+    save_rentals
+    returned_video = search_video(aRental.video)
+    returned_video.state = :available
+  end
+
+  private
+  def init_catalogue()
+    filepath = MyDir + CatalogueFile
+    if File.exist?(filepath)
+      @catalogue = YAML.load_file(filepath)
+    else
+      @catalogue = []
+    end
+  end
+  
+  def init_members()
+    filepath = MyDir + MembersFile
+    if File.exist?(filepath)
+      @members = YAML.load_file(filepath)
+    else
+      @members = []
+    end
+  end
+  
+  def init_users()
+    filepath = MyDir + UsersFile
+    if File.exist?(filepath)
+      @users = YAML.load_file(filepath)
+    else
+      @users = []
+    end  
+  end
+  
+  def init_rentals()
+    filepath = MyDir + RentalsFile
+    if File.exist?(filepath)
+      @rentals = YAML.load_file(filepath)
+    else
+      @rentals = []
+    end
+  end
+  
+  def zap_rentals!()
+    rentals.clear
+    save_rentals()
+  end
+  
+  def zap_members!()
+    members.clear
+    save_members()
+  end
+  
+  def save_catalogue()
+    filepath = MyDir + CatalogueFile
+    File.open(filepath, 'w') {|f| YAML.dump(catalogue, f)}
+  end
+
+  def save_members()
+    filepath = MyDir + MembersFile
+    File.open(filepath, 'w') {|f| YAML.dump(members, f)}
+  end
+
+  def save_users()
+    filepath = MyDir + UsersFile
+    File.open(filepath, 'w') {|f| YAML.dump(users, f)}
+  end
+
+  def save_rentals()
+    filepath = MyDir + RentalsFile
+    File.open(filepath, 'w') {|f| YAML.dump(rentals, f)}
+  end
+
+end # class
+
+end # module
+
+# End of file

data/spec/cukedep/application_spec.rb

@@ -0,0 +1,81 @@
+# File: cmd-line_spec.rb
+
+require 'stringio'
+require_relative '../spec_helper'
+
+# Load the class under testing
+require_relative '../../lib/cukedep/application'
+
+module Cukedep # Open module to get rid of long qualified names
+
+describe Application do
+
+  context 'Creation & initialization:' do
+    it 'should be created without argument' do
+      expect { Application.new }.not_to raise_error
+    end
+  end # context
+  
+  context 'Provided services:' do
+    subject { Application.new }
+    
+    it 'should read its command-line' do
+      options = subject.send(:options_from, %w[])
+      expect(options).to be_empty
+    end
+    
+    it 'should generate a user settings file' do
+      # Start state: no config
+      File.delete(Cukedep::YMLFilename) if File.exist?(Cukedep::YMLFilename)
+      
+      # --setup option creates the config file then stops the application
+      expect { subject.start!(['--setup'])}.to raise_error(SystemExit)
+      
+      # Check that the config file was effectively created.
+      expect { File.exist?(Cukedep::YMLFilename) }.to be_true
+      created_config = subject.send(:load_cfg)
+      expect(created_config).to eq(Config.default)
+      
+      # Re-run again with --setup option.
+      # It should ask permission for overwriting
+      # Capture console IO
+      old_stdout = $>
+      ostream = StringIO.new('rw')
+      $> = ostream
+      old_stdin = $stdin
+      $stdin = StringIO.new("n\n", 'r')
+      expect { subject.start!(['--setup'])}.to raise_error(SystemExit)
+      $> = old_stdout
+      $sdtin = old_stdin
+    end
+    
+    it 'should complain in absence of project dir' do
+      # Start state: no config
+      File.delete(Cukedep::YMLFilename) if File.exist?(Cukedep::YMLFilename)
+      expect(File.exist?(Cukedep::YMLFilename)).to be_false
+      
+      # Create default config
+      expect { subject.start!(['--setup'])}.to raise_error(SystemExit)
+        
+      err = StandardError
+      err_msg = "No project dir specified via 'Cukedep::YMLFilename' nor via --project option."
+      expect {subject.start!([])}.to raise_error(err, err_msg)
+    end
+    
+    it 'should parse the feature files' do
+      curr_dir = Dir.getwd()
+      begin
+        file_dir = File.dirname(__FILE__)
+        Dir.chdir(file_dir + '/sample_features')
+        unless File.exist?(Cukedep::YMLFilename)
+          expect { subject.start!(['--setup'])}.to raise_error(SystemExit)
+        end
+        subject.start!(['--project', '../../../sample'])
+      ensure
+        Dir.chdir(curr_dir)
+      end
+    end
+  end # context
+end # describe
+
+end # module

data/spec/cukedep/cli/cmd-line_spec.rb

@@ -0,0 +1,91 @@
+# File: cmd-line_spec.rb
+
+require 'stringio'
+require_relative '../../spec_helper'
+
+# Load the class under testing
+require_relative '../../../lib/cukedep/cli/cmd-line'
+
+module Cukedep # Open module to get rid of long qualified names
+
+describe CLI::CmdLine do
+
+  context 'Creation & initialization:' do
+    subject { CLI::CmdLine.new }
+
+    it 'should be created without argument' do
+    expect { CLI::CmdLine.new }.not_to raise_error
+    end
+  end # context
+  
+  context 'Provided services:' do
+    def capture_output()
+      @output = $>
+      ostream = StringIO.new('rw')
+      $> = ostream
+    end
+    
+    def release_output()
+      $> = @output
+    end
+
+  
+    it 'should accept an empty command-line' do
+      expect { subject.parse!([]) }.not_to raise_error
+      expect(subject.options).to be_empty
+    end
+
+    it 'should accept the dry-run option' do
+      expect { subject.parse!(['--dry-run']) }.not_to raise_error
+      expect(subject.options).to eq({ :"dry-run" => true })
+    end
+
+    it 'should accept the setup option' do
+      expect { subject.parse!(['--setup']) }.not_to raise_error
+      expect(subject.options).to eq({ :setup => true })
+    end
+    
+    it 'should validate the project option argument' do
+      # Case 1: missing project dir argument
+      cmd_opts = ['--project']
+      err_type = StandardError
+      err_msg = <<-MSG_END
+No argument provided with command line option: --project
+To see the command-line syntax, do:
+cukedep --help
+MSG_END
+      expect { subject.parse!(cmd_opts) }.to raise_error(err_type)
+      
+      # Case 2: non existing project dir
+      cmd_opts = ['--project', 'nowhere']
+      err_msg = "Cannot find the directory 'nowhere'."
+      expect { subject.parse!(cmd_opts) }.to raise_error(err_type, err_msg) 
+
+      # Case 3: project dir exists
+      #cmd_opts = ['--project', '../../../sample']
+      #expect { subject.parse!(cmd_opts) }.not_to raise_error
+      #expect(subject.options).to eq({ :project => '../../../sample' })
+    end
+
+    it 'should handle the version option' do
+      capture_output
+      cmd_opts = ['--version']
+      expect { subject.parse!(cmd_opts) }.to raise_error(SystemExit)
+      expect($>.string).to eq(Cukedep::Version + "\n")
+      release_output
+    end
+
+    it 'should handle the help option' do
+      capture_output
+      cmd_opts = ['--help']
+      expect { subject.parse!(cmd_opts) }.to raise_error(SystemExit)
+      expect($>.string).to eq(subject.parser.to_s)      
+      release_output
+    end
+  end # context
+  
+  
+
+end # describe
+
+end # module