fir 0.0.9 → 0.0.10

data/spec/generator_spec.rb

@@ -0,0 +1,132 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Fir.generate!' do
+	def fir_root
+		@fir_root ||= File.expand_path(File.join(File.dirname(__FILE__), '..', 'gen_test_example'))
+	end
+	
+	# Args should be a string, e.g. '--with-dispatch-cgi --with-htaccess'
+	def generate(args = '')
+		begin
+			original_dir = Dir.getwd
+			bin = File.join(File.dirname(__FILE__), '..', 'bin', 'fir')
+			`export TESTING_FIR_BIN=1;#{bin} #{fir_root} #{args}`
+			Dir.chdir fir_root
+			yield
+		ensure
+			Dir.chdir original_dir
+			FileUtils::rm_rf fir_root
+		end
+	end
+	
+	def assert_generator_creates(should_create, path_components)
+		path_components.unshift(fir_root) unless path_components.first == fir_root
+		generate do
+			if should_create
+				File.join(path_components).should exist_on_disk
+			else
+				File.join(path_components).should_not exist_on_disk
+			end
+		end
+	end
+	
+	def generator_should_create(*path_components)
+		assert_generator_creates(true, path_components)
+	end
+	
+	def generator_should_not_create(*path_components)
+		assert_generator_creates(false, path_components)
+	end
+	
+	it 'creates a Fir site that can be booted with Rackup' do
+		generate do
+			[fir_root, 'rackup -p 3001'].should spawn_working_server
+		end
+	end
+	
+	it 'creates the root directory' do
+		generator_should_create fir_root
+	end
+	
+	it 'creates the pages directory' do
+		generator_should_create 'pages'
+	end
+	
+	it 'creates the layouts directory' do
+		generator_should_create 'layouts'
+	end
+	
+	it 'creates the public directory' do
+		generator_should_create 'public'
+	end
+	
+	it 'creates the tmp directory' do
+		generator_should_create 'tmp'
+	end
+	
+	it 'creates config.rb' do
+		generator_should_create 'config.rb'
+	end
+	
+	it 'does not create .htaccess by default' do
+		generator_should_not_create 'public', '.htaccess'
+	end
+	
+	it 'creates .htaccess if --with-htaccess is given' do
+		generate('--with-htaccess') do
+			File.join(fir_root, 'public', '.htaccess').should exist_on_disk
+		end
+	end
+	
+	it 'does not create dispatch.cgi by default' do
+		generator_should_not_create 'public', 'dispatch.cgi'
+	end
+	
+	it 'creates dispatch.cgi if --with-dispatch-cgi is given' do
+		generate('--with-dispatch-cgi') do
+			File.join(fir_root, 'public', 'dispatch.cgi').should exist_on_disk
+		end
+	end
+	
+	describe 'config.rb' do
+		it 'calls Fir.config' do
+			generate do
+				Fir.should_receive(:config)
+				load File.join(fir_root, 'config.rb')
+			end
+		end
+		
+		it 'sets the default site name' do
+			generate do
+				Fir.config.should_receive(:site_name=)
+				load File.join(fir_root, 'config.rb')
+			end
+		end
+	end
+	
+	it 'creates menus.yml' do
+		generator_should_create 'menus.yml'
+	end
+	
+	it 'creates pages.yml' do
+		generator_should_create 'pages.yml'
+	end
+	
+	it 'creates Rakefile' do
+		generator_should_create 'Rakefile'
+	end
+	
+	describe 'Rakefile' do
+		it 'has a task called users:add' do
+			generate do
+				`rake -D`.should include('users:add')
+			end
+		end
+		
+		it 'has a task called export' do
+			generate do
+				`rake -D`.should include('export')
+			end
+		end
+	end
+end

data/spec/rack_integration_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# This is where we test with real, honest-to-goodness server processes.
+# The point is to ensure that Fir can integrate with Rack-compliant servers.
+
+describe 'Rack integration' do
+	def fir_root
+		@fir_root ||= File.expand_path(File.join(File.dirname(__FILE__), '..', 'example'))
+	end
+	
+	def home_should_be_accessible(options = {})
+		options = {:host => 'localhost', :port => 3001}.merge(options)
+		retry_request do
+			Net::HTTP.get(URI.parse("http://#{options[:host]}:#{options[:port]}")).should contain('Welcome to Acme Company!')
+		end
+	end
+	
+	context 'with rackup' do
+		it 'allows access to the home page' do
+			with_spawned_server(fir_root, 'rackup -p 3001') do
+				home_should_be_accessible
+			end
+		end
+	end
+	
+	context 'with CGI' do
+		# This is a simple way to test CGI support. We can't
+		# test against Apache, because that requires installing and configuring
+		# it, which we obviously can't do in this test suite. Sadly, this means we
+		# can't test .htaccess. That's a shame, because there is a very real
+		# possibility of errors creeping into .htaccess.
+		# 
+		# Instead, we set up a mock CGI environment by setting environment variables.
+		# 
+		# It would be even better if we could test this against a light web server running
+		# in a forked process, but there doesn't seem to be an easy way to do that.
+		it 'allows access to the home page' do
+			dispatch = File.join(fir_root, 'public', 'dispatch.cgi')
+			response = `export PATH_INFO=/; ruby #{dispatch}`
+			response.should include('Status: 200')
+			response.should include('Welcome to Acme Company!')
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,23 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'fir'
+require 'fir/generator'
 require 'spec'
 require 'spec/autorun'
+require 'rack/test'
+require 'webrat'
+require 'rake'
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+FIR_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', 'example'))
 
 Spec::Runner.configure do |config|
-	
-end
+	config.include Rack::Test::Methods
+	config.include Webrat::Matchers
+	config.include Fir::TestAppSetup
+	config.include Fir::CacheTesting
+	config.include Fir::ServerTesting
+	config.include Fir::FileMatchers
+	config.include Fir::ServerMatchers
+end

data/spec/support/cache_testing.rb

@@ -0,0 +1,20 @@
+module Fir
+	module CacheTesting
+		# Path should be like this:
+		#   directory/page
+		# Not this:
+		#   directory/page.html
+		def with_cache(path, contents)
+			filename = File.join(FIR_ROOT, 'public', 'cache', path + '.html')
+			dirname = File.dirname(filename)
+			unless File.directory?(dirname)
+				FileUtils.mkdir_p(dirname)
+			end
+			File.open(filename, 'w') do |file|
+				file.write(contents)
+			end
+			yield
+			File.delete(filename)
+		end
+	end
+end

data/spec/support/file_matchers.rb

@@ -0,0 +1,22 @@
+module Fir
+	module FileMatchers
+		class ExistOnDisk
+			def matches?(path)
+				@path = path
+				File.exists?(path)
+			end
+			
+			def failure_message
+				"Expected #{@path} to exist"
+			end
+			
+			def negative_failure_message
+				"Expected #{@path} not to exist"
+			end
+		end
+		
+		def exist_on_disk
+			ExistOnDisk.new
+		end
+	end
+end

data/spec/support/server_matchers.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'server_testing.rb'))
+
+module Fir
+	module ServerMatchers
+		class SpawnWorkingServer
+			include Fir::ServerTesting
+			
+			def matches?(command_arr)
+				@dir = command_arr[0]
+				@command = command_arr[1]
+				@host_and_port = command_arr[2] || 'localhost:3001'
+				@response = nil
+				with_spawned_server(@dir, @command) do
+					retry_request do
+						@response = Net::HTTP.get(URI.parse("http://#{@host_and_port}"))
+					end
+				end
+				@response.is_a?(String) and @response.include?('Home')
+			end
+			
+			def failure_message
+				"Expected that running #{@command} in #{@dir} would spawn a working server at #{@host_and_port}. Response: #{@response.inspect}"
+			end
+			
+			def negative_failure_message
+				"Expected that running #{@command} in #{@dir} would not spawn a working server at #{@host_and_port}. Response: #{@response.inspect}"
+			end
+		end
+		
+		# Usage:
+		#   [dir, command, host_and_port].should spawn_working_server
+		# This will cd to dir, try to spawn a server with command,
+		# and try to GET http://host_and_port. host_and_port is optional.
+		# It defaults to localhost:3001.
+		def spawn_working_server
+			SpawnWorkingServer.new
+		end
+	end
+end

data/spec/support/server_testing.rb

@@ -0,0 +1,35 @@
+module Fir
+	module ServerTesting
+		def with_spawned_server(dir, command)
+			original_dir = Dir.getwd
+			Dir.chdir(dir)
+			begin
+				server_pid = fork do
+					puts 'About to spawn server.'
+					exec command
+				end
+				response = ''
+				yield
+			ensure
+				puts "About to kill server. The interrupt message is normal. Don't worry about it."
+				Process.kill('INT', server_pid)
+				Dir.chdir(original_dir)
+			end
+		end
+		
+		def retry_request
+			failures = 0
+			begin
+				yield
+			rescue Errno::ECONNREFUSED => exc
+				failures += 1
+				if failures == 3
+					raise exc
+				else
+					sleep((2 ** failures) * 0.3)
+					retry
+				end
+			end
+		end
+	end
+end

data/spec/support/test_app_setup.rb

@@ -0,0 +1,11 @@
+module Fir
+	module TestAppSetup
+		def app
+			Rack::Builder.new(&Fir.boot_proc)
+		end
+		
+		def load_config
+			require File.expand_path(File.join(FIR_ROOT, 'config.rb'))
+		end
+	end
+end

data/spec/tasks_spec.rb

@@ -0,0 +1,132 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Fir Rake tasks' do
+	Fir::Tasks.define # Some tasks need to be executed within this Ruby instance so that we can use stubs, method expectations, etc.
+	
+	def fir_root
+		@fir_root ||= File.expand_path(File.join(File.dirname(__FILE__), '..', 'example'))
+	end
+	
+	def rake(args)
+		original_wd = Dir.getwd
+		output = nil
+		begin
+			Dir.chdir(fir_root)
+			output = `export TESTING_FIR_TASKS=1;rake #{args}`
+		ensure
+			Dir.chdir(original_wd)
+		end
+		output
+	end
+	
+	describe 'users:add' do
+		it 'adds a new user with hashed and salted password' do
+			yaml_path = File.join(fir_root, 'users.yml')
+			original_yaml = YAML::load(File.read(yaml_path))
+			begin
+				rake('users:add user=someone pass=password')
+				new_yaml = YAML::load(File.read(yaml_path))
+				new_yaml.should have_key('someone')
+				salt = new_yaml['someone']['salt']
+				new_yaml['someone']['crypted_password'].should == Fir.encrypt_password('password', salt)
+			ensure
+				File.open(yaml_path, 'w') do |file|
+					file.write(YAML::dump(original_yaml))
+				end
+			end
+		end
+	end
+	
+	describe 'export' do
+		def export(extra_args = nil)
+			output = nil
+			begin
+				output = rake("export dir=\"../exported_example\" #{extra_args}")
+				yield if block_given?
+			ensure
+				FileUtils.rm_rf export_root
+			end
+			output
+		end
+		
+		def export_root
+			File.expand_path File.join(fir_root, '..', 'exported_example')
+		end
+		
+		def should_export(*path_components)
+			path_components.unshift(export_root) unless path_components.first == export_root
+			export do
+				File.join(path_components).should exist_on_disk
+			end
+		end
+		
+		def with_existing_files
+			begin
+				Dir.mkdir(export_root)
+				old_file_path = File.join(export_root, 'old.txt')
+				File.open(old_file_path, 'w') { |file| file.write 'Old' }
+				yield
+			ensure
+				FileUtils.rm_rf export_root
+			end
+		end
+		
+		it 'creates the root directory' do
+			should_export export_root
+		end
+		
+		it 'fails if the root directory is not empty and the force option was not given' do
+			with_existing_files do
+				export.should include('Directory is not empty')
+				File.join(export_root, 'index.html').should_not exist_on_disk
+			end
+		end
+		
+		it 'overwrites everything if the root directory exists and the force option was given' do
+			with_existing_files do
+				export('force=1') do
+					File.join(export_root, 'old.txt').should_not exist_on_disk
+				end
+			end
+		end
+	end
+	
+	describe 'export_to_server' do
+		def run_export_to_server
+			ENV['dest'] = 'username@host.com:/home/username/public_html'
+			Rake::Task['export_to_server'].execute
+		end
+		
+		before :each do
+			@rsyncer = ::Fir::Tasks::Rsyncer.new
+			::Fir::Tasks::Rsyncer.stub(:new).and_return(@rsyncer)
+			@rsyncer.stub(:run_command)
+		end
+		
+		it 'exports the site first' do
+			begin
+				export_root = File.expand_path(File.join(File.dirname(__FILE__), 'testable_export_tmp'))
+				@rsyncer.stub(:run_command).and_return do
+					FileUtils.cp_r('.server_export_tmp', export_root)
+				end
+				run_export_to_server
+				export_root.should exist_on_disk
+				File.join(export_root, 'index.html').should exist_on_disk
+				File.join(export_root, 'products', 'index.html').should exist_on_disk
+			ensure
+				FileUtils.rm_rf export_root
+			end
+		end
+		
+		it 'rsyncs the exported site to the server' do
+			@rsyncer.should_receive(:run_command).with('rsync -ave ssh .server_export_tmp/* username@host.com:/home/username/public_html')
+			run_export_to_server
+		end
+		
+		it 'uses deploy.yml if it exists' do
+			ENV['dest'] = nil
+			@rsyncer.should_receive(:run_command).with('rsync -ave ssh .server_export_tmp/* me@example.com:/www-root')
+			Rake::Task['export_to_server'].execute
+		end
+	end
+end