spectie 0.0.3

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2009 Ryan Kinderman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,85 @@
+= Spectie
+
+Spectie (rhymes with "necktie") is a pure Ruby BDD integration testing framework for RSpec. 
+
+Spectie was written with the following beliefs:
+
+* Business stakeholders or analysts are often not writing comprehensive (or any) acceptance criteria.
+* Business stakeholders or analysts are usually unwilling or unable to follow a strict format for writing the acceptance criteria that they _are_ writing.
+* On many projects, the communication with the business stakeholders or analysts are accessible enough that written acceptance criteria is not necessary, but discussed requirements still need to be implemented, and therefore need to be tested.
+* Good developers recognize the benefits of top-down, BDD-style integration testing in helping to ensure that the code that is written to implement a feature directly satisfies business requirements, and doesn't get over-engineered or over-complicated.
+* Good developers love Ruby.
+
+Spectie tries to strike the proper balance between writing readable tests, and just getting your work done in the most efficient way possible. It does this by providing a consistent structure for writing your integration test code in a BDD fashion, with the breakdown of features, scenarios, and their given/when/then statements. However, a little bit of syntactic sugar goes a long way to aid in the understanding of code, while too much can add unnecessary complexity and actually decrease maintainability.  So, Spectie keeps things pretty close to the underlying technology at all times, since most of the time, it's a developer that's *really* writing the tests.
+
+With these ideas in mind, what Spectie provides is:
+
+* A small number of methods on top of RSpec for making your integration tests readable. This isn't much more than "Given/When/Then".
+* A configuration and mapping layer for different integration testing code, such as what's provided by ActionController's integration.rb, or the Ruby client for Selenium.
+* Common functionality for supported integration testing solutions, such as the option to restart the Selenium browser between tests, or simply clear the cookies.
+
+Advantages of having your integration tests written with Spectie:
+
+* It's Ruby.
+* If you're familiar with RSpec already, all the same functionality is available.
+* All new syntax beyond RSpec is kept to a minimum, and exists solely to facilitate developer-driven BDD.
+* Use familiar methods for code navigation and reuse.
+
+== Example
+=== Rails
+  Feature "Compelling Feature" do
+    Scenario "As a user, I would like to use a compelling feature" do
+      Given :i_have_an_account
+      And   :i_have_logged_in
+
+      When  :i_access_a_compelling_feature
+
+      Then  :i_am_presented_with_stunning_results
+    end
+
+    def i_have_an_account
+      @user = create_user
+    end
+
+    def i_have_logged_in
+      log_in_as @user
+    end
+
+    def i_access_a_compelling_feature
+      get compelling_feature_path
+      response.should be_success
+    end 
+
+    def i_am_presented_with_stunning_results
+      response.should have_text("Simply stunning!")
+    end
+  end
+
+== Installation
+
+=== Gem
+  sudo gem install spectie
+
+=== Rails plugin
+  script/plugin install git://github.com/ryankinderman/spectie.git 
+
+=== Git
+  git clone git://github.com/ryankinderman/spectie.git
+
+== Configuration
+=== Ruby on Rails
+In <em>spec/spec_helper.rb</em>, after <tt>require 'spec/rails'</tt>, add:
+  require 'spectie/rails'
+
+That's it. Spectie registers itself with RSpec, so you can run your integration tests with the usual <tt>rake spec:integration</tt> command. Also, all of the usual methods in a {Rails integration testing session}[http://api.rubyonrails.org/classes/ActionController/Integration/Session.html] are available for you to use as well.
+
+=== Selenium
+TODO
+
+== Author
+
+Ryan Kinderman (ryan@kinderman.net)
+
+== Copyright
+
+Copyright (c) 2009 Ryan Kinderman. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'rake'
+require File.expand_path(File.dirname(__FILE__) + "/initialize")
+
+Dir[File.expand_path(File.dirname(__FILE__) + "/rake_tasks/*.rake")].each do |file|
+  load file
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 0
+:patch: 3
+:major: 0

data/initialize.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+
+Dir[File.dirname(__FILE__) + "/vendor/*/lib"].each do |lib|
+  lib_path = File.expand_path(lib)
+  $:.unshift lib_path unless $:.include?(lib_path)
+end

data/lib/spectie.rb

@@ -0,0 +1,3 @@
+require "spectie/story_example_group_methods"
+require "spectie/configuration"
+require "spectie/main.rb"

data/lib/spectie/configuration.rb

@@ -0,0 +1,10 @@
+module Spectie
+  module Configuration
+    class ForScenarios
+    end
+    def scenarios
+      ForScenarios.new
+    end
+  end
+  ::Spec::Runner::Configuration.send :include, Configuration
+end

data/lib/spectie/main.rb

@@ -0,0 +1,26 @@
+module Spectie
+  module Main
+    # Creates an example group for the feature.
+    #   Feature "User Authentication" do
+    #     Scenario "As a user without an account, I want to create one so that I can log in" do
+    #       Given :i_do_not_have_an_account
+    #       And   :i_want_to_log_in
+    #
+    #       When  :i_create_an_account
+    #
+    #       Then  :i_can_log_in
+    #     end
+    #
+    #     def i_do_not_have_an_account
+    #       # ... codey code ...
+    #     end
+    #
+    #     # ... remaining scenario statements ...
+    #   end
+    def Feature(*args, &block)
+      describe(*args, &block)
+    end
+  end
+end
+
+include Spectie::Main

data/lib/spectie/rails.rb

@@ -0,0 +1,2 @@
+require "spectie"
+require "spectie/rails_story_example_group"

data/lib/spectie/rails_story_example_group.rb

@@ -0,0 +1,55 @@
+###################################################################################
+# Preserve method_missing from rspec, which supports the general 
+# be_ and have_ predicate matchers. This method gets overridden for
+# Rails integration tests by ActionController::IntegrationTest for
+# session delegation.
+require "spec/interop/test/unit/testcase"
+Test::Unit::TestCase.class_eval do 
+  alias_method :method_missing_from_rspec, :method_missing
+end
+
+require "action_controller/integration"
+ActionController::IntegrationTest.class_eval do
+  alias_method :method_missing_from_rails, :method_missing
+  def method_missing(*args, &block)
+    method_missing_from_rspec(*args, &block)
+  rescue NameError
+    method_missing_from_rails(*args, &block)
+  end
+end
+###################################################################################
+begin
+  spec_rails_path = "spec/rails"
+  require spec_rails_path
+rescue LoadError => e
+  if e.message =~ /#{Regexp.escape(spec_rails_path)}$/
+    raise "RSpec-Rails not available. Install it with sudo gem install rspec-rails"
+  else
+    raise e
+  end
+end
+
+ActionController::IntegrationTest.class_eval do
+  alias_method :orig_initialize, :initialize
+  def initialize(*args)
+    super
+  end
+end
+
+module Spectie
+
+  class RailsStoryExampleGroup < ActionController::IntegrationTest
+    include StoryExampleGroupMethods
+
+    # The following line ensures that RailsStoryExampleGroup is, by 
+    # default, the lowest point in the example group hierarchy that 
+    # helper modules will be included.
+    #
+    # If that doesn't make sense, just comment this line
+    # out and observe the failing test.
+    Spec::Example::ExampleGroupFactory.default(self)
+    Spec::Example::ExampleGroupFactory.register(:integration, self)
+  end
+
+end
+

data/lib/spectie/selenium.rb

@@ -0,0 +1,3 @@
+require "spectie"
+require "spectie/selenium/configuration"
+require "spectie/selenium/story_example_group"

data/lib/spectie/selenium/configuration.rb

@@ -0,0 +1,27 @@
+module Spectie
+  module Configuration
+    class Selenium
+      attr_writer :driver_options
+      attr_accessor :start_browser_once, :controlled
+
+      def initialize
+        self.start_browser_once = true
+        self.controlled = true
+      end
+
+      def driver_options
+        @driver_options || raise("No Selenium driver options specified")
+      end
+
+      def controlled?
+        self.controlled == true
+      end
+
+    end
+
+    def selenium
+      @selenium ||= Selenium.new
+    end
+  end
+  ::Spec::Runner.send :include, Configuration
+end

data/lib/spectie/selenium/story_example_group.rb

@@ -0,0 +1,51 @@
+begin
+  selenium_client_path = "selenium/client" 
+  require selenium_client_path
+rescue LoadError => e
+  if e.message =~ /#{Regexp.escape(selenium_client_path)}$/
+    raise "selenium-client not available. Install it with sudo gem install selenium-client"
+  else
+    raise e
+  end
+end
+
+module Spectie
+  class SeleniumStoryExampleGroup
+    include StoryExampleGroupMethods
+    include Selenium::Client::SeleniumHelper
+
+    selenium = nil
+    selenium_config = Spec::Runner.configuration.selenium
+
+    before :suite do
+      if selenium_config.controlled? and selenium_config.start_browser_once
+        selenium = Selenium::Client::Driver.new(selenium_config.driver_options)
+        selenium.start
+      end
+    end
+
+    after :suite do
+      if selenium_config.controlled? and selenium_config.start_browser_once
+        selenium.stop
+      end
+    end
+
+    before :each do
+      if selenium_config.controlled? and !selenium_config.start_browser_once
+        selenium = Selenium::Client::Driver.new(selenium_config.driver_options)
+        selenium.start
+      end
+      @selenium = selenium
+    end
+
+    after :each do
+      if selenium_config.controlled?
+        if selenium_config.start_browser_once
+          selenium.delete_all_visible_cookies
+        else
+          selenium.stop
+        end
+      end
+    end
+  end
+end

data/lib/spectie/story_example_group_methods.rb

@@ -0,0 +1,40 @@
+module Spectie
+
+  module StoryExampleGroupMethods
+    def self.included(mod)
+      mod.class_eval do 
+        extend Spec::Example::ExampleGroupMethods
+        include Spec::Example::ExampleMethods
+
+        class << self
+
+          def scenario_methods; [:Given, :When, :Then, :And] end
+
+          # Creates a scenario example within a feature (see Spectie::Main#Feature).
+          def Scenario(description, options={}, backtrace=nil, &implementation)
+            example(description, options, backtrace) do
+              instance_eval &implementation
+            end
+          end
+
+          # Disables a scenario.
+          def xScenario(description, options={}, &implementation)
+            xexample description, options, &implementation
+          end
+
+        end
+
+        scenario_methods.each do |scenario_method|
+          method = <<-METHOD
+          def #{scenario_method}(statement, *args, &block)
+            send statement, *args, &block
+          end
+          METHOD
+
+          class_eval method, __FILE__, __LINE__
+        end
+
+      end
+    end
+  end
+end

data/rake_tasks/package.rake

@@ -0,0 +1,51 @@
+namespace :package do
+  begin
+    require 'jeweler'
+    Jeweler::Tasks.new do |gem|
+      gem.name = %q{spectie}
+      gem.summary = %q{A Ruby integration testing framework written on top of RSpec.}
+      gem.description = <<-EOF
+        Spectie (rhymes with "necktie") is a pure Ruby acceptance testing framework for RSpec. 
+        The philosophy of Spectie is that, since the business stakeholders on most projects
+        don't care about exactly how you test, you're free to write the acceptance tests on
+        a project how *you*, the developer, need to in order to ensure that the implementation
+        is correct, easily understood, and maintainable. Furthermore, since you're a developer, 
+        the easiest, most straight-forward and maintainable way for you to write your tests is
+        by using the highly expressive language that you're already coding in for the project;
+        that's Ruby, baby!
+      EOF
+      gem.platform = Gem::Platform::RUBY
+      gem.required_ruby_version = '>= 1.8.6'
+      gem.add_dependency('rspec', '>= 1.2.7')
+
+      gem.authors = ["Ryan Kinderman"]
+      gem.date = Time.now.strftime("%Y-%m-%d")
+      gem.email = %q{ryan@kinderman.net}
+      gem.homepage = %q{http://github.com/ryankinderman/spectie}
+      gem.rubyforge_project = %q{kinderman}
+
+      gem.has_rdoc = true
+      gem.rdoc_options = ["--charset=UTF-8"]
+      gem.extra_rdoc_files = [
+        "LICENSE",
+        "README.rdoc"
+      ]
+
+      gem.require_paths = ["lib"]
+      gem.files = Dir["**/*"] 
+      gem.files.reject! { |f| !f.match(/^(vendor|pkg)(\/|$)/).nil? }
+      gem.test_files = Dir["spec/**/*_spec.rb"]
+
+      # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+    end
+
+    Jeweler::RubyforgeTasks.new do |rubyforge|
+      rubyforge.doc_task = "rdoc"
+    end    
+  rescue LoadError
+    puts "Jeweler not available. It's only needed if you're going to build the gem for this library. Install it with something like: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+  end
+
+  desc "Cleans the project package artifacts, generates all files needed to build the gem, and builds it"
+  task :full => ["clean", "rdoc", "gemspec", "build"]
+end

data/rake_tasks/publish.rake

@@ -0,0 +1,40 @@
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "spectie #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rake/contrib/sshpublisher'
+  namespace :rubyforge do
+
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+
+    namespace :release do
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/spectie/"
+        local_dir = 'rdoc'
+
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end