data_active 0.0.1

data/features/step_definitions/step_helper.rb

@@ -0,0 +1,15 @@
+module StepHelper
+  def StepHelper.load_fixtures(path)
+    fixtures_folder = path
+    fixtures = Dir[File.join(fixtures_folder, '*.yml')].map {|f| File.basename(f, '.yml') }
+
+    if defined? Fixtures == nil
+      Fixtures.reset_cache
+      Fixtures.create_fixtures(fixtures_folder, fixtures)
+    else
+      ActiveRecord::Fixtures.reset_cache
+      ActiveRecord::Fixtures.create_fixtures(fixtures_folder, fixtures)
+    end
+  end
+end
+

data/features/step_definitions/sync_books_with_xml.rb

@@ -0,0 +1,224 @@
+require "nokogiri"
+require "data_active"
+require_relative "step_helper"
+require "active_record/fixtures"
+
+Given /^I have no books$/ do
+  Book.destroy_all
+  books_in_database = Book.all
+  if books_in_database.count > 0
+    fail "Records still exist in the database"
+  end
+end
+
+When /^I have the "([^"]*)" file$/ do |xml_document_file|
+  if File.exists?(xml_document_file)
+    xml_document = Nokogiri::XML(File.open(Rails.root.join(xml_document_file)).read)
+    xml_document.children.first.name.downcase.eql?("books") || xml_document.children.first.name.downcase.eql?("book")
+  else
+    fail "XML File doesn't exist"
+  end
+end
+
+When /^I synchronise with "([^"]*)"$/ do |xml_document_file|
+  Book.many_from_xml(File.open(Rails.root.join(xml_document_file)).read, [:sync]) != nil
+end
+
+When /^I synchronise with "([^"]*)" I should get an error$/ do |xml_document_file|
+  begin
+    Book.many_from_xml(File.open(Rails.root.join(xml_document_file)).read, [:sync]) != nil
+    fail "Error was didn't happen"
+  rescue Exception => e
+    if e.message.exclude? "Too many records for one to one association"
+      fail "Wrong exception was raised"
+    end
+  end
+end
+
+When /^I update with "([^"]*)"$/ do |xml_document_file|
+  @original_books = Book.all
+  @original_chapters = Chapter.all
+  @original_pages = Page.all
+  Book.many_from_xml(File.open(Rails.root.join(xml_document_file)).read, [:update]) != nil
+end
+
+Then /^the books in the database will be identical to those in "([^"]*)"$/ do |xml_document_file|
+  books_in_database = Book.all
+  if books_in_database.count > 0
+    books_xml_document = Nokogiri::XML(File.open(Rails.root.join(xml_document_file)).read)
+
+    # Ensure that all books in the xml document have been recorded
+    book_elements = books_xml_document.xpath("//book")
+    book_elements.each do |book_element|
+      book_id = book_element.xpath("//book/id")[0].text
+      book_name = book_element.xpath("//book/name")[0].text
+      book = Book.find(book_id)
+      if book == nil
+        fail "Books with id #{book_id} is missing"
+      else
+        if book_name != book.name
+          fail "Book name in database doesn't match book name in xml for book with id #{book_id}, XML: #{book_name}, Database: #{book.name}"
+        end
+      end
+    end
+
+    # Ensure there are not extra books
+    books_in_xml = books_xml_document.xpath("//book")
+    if books_in_database.count != books_in_xml.count
+      fail "There number of books in the database (#{books_in_database.count}) doesn't match the number of books in the xml document (#{books_in_xml.count})"
+    end
+
+  else
+    fail "no books recorded"
+  end
+end
+
+When /^the book price will be identical to those in "([^"]*)"$/ do |xml_document_file|
+  book_prices_in_database = BookPrice.all
+  if book_prices_in_database.count > 0
+    xml_document = Nokogiri::XML(File.open(Rails.root.join(xml_document_file)).read)
+
+    # Ensure that all chapters in the xml document have been recorded
+
+    xml_document.xpath("//book").each do |book_element|
+      book_id = book_element.xpath("id").text
+
+      xml_document.xpath("//book[id[text()='#{book_id}']]/book_price").each do |book_price_element|
+        book_price_id = book_price_element.xpath("id")[0].text
+        book_price = BookPrice.find book_price_id
+        if book_price.nil?
+          fail "BookPrice with id #{book_price_id} is missing"
+        else
+          book_price_sell = book_price_element.xpath("sell").text
+          book_price_educational = book_price_element.xpath("educational").text
+          book_price_cost = book_price_element.xpath("cost").text
+
+          if Float(book_price_sell) != book_price.sell
+            fail "BookPrice 'sell' in database doesn't match book price sell in xml for book price with id #{book_price_id}, XML: #{book_price_sell}, Database: #{book_price.sell}"
+          end
+
+          if Float(book_price_cost) != book_price.cost
+            fail "BookPrice 'cost' in database doesn't match book price cost in xml for book price with id #{book_price_id}, XML: #{book_price_cost}, Database: #{book_price.cost}"
+          end
+
+          if Float(book_price_educational) != book_price.educational
+            fail "BookPrice 'educational' in database doesn't match book price educational in xml for book price with id #{book_price_id}, XML: #{book_price_educational}, Database: #{book_price.educational}"
+          end
+
+          if Integer(book_id) != book_price.book_id
+            fail "BookPrice 'book_id' in database doesn't match book_id in xml for book price with id #{book_price_id}, XML: #{book_id}, Database: #{book_price.book_id}"
+          end
+        end
+      end
+    end
+
+    # Ensure there are not extra book prices
+    book_prices_in_xml = xml_document.xpath("//book_price")
+    if book_prices_in_database.count != book_prices_in_xml.count
+      fail "There number of book prices in the database (#{book_prices_in_database.count}) doesn't match the number of book prices in the xml document (#{book_prices_in_xml.count})"
+    end
+  end
+end
+
+When /^the chapters will be identical to those in "([^"]*)"$/ do |xml_document_file|
+  chapters_in_database = Chapter.all
+  if chapters_in_database.count > 0
+    xml_document = Nokogiri::XML(File.open(Rails.root.join(xml_document_file)).read)
+
+    # Ensure that all chapters in the xml document have been recorded
+    xml_document.xpath("//book").each do |book_element|
+      book_id = book_element.xpath("id").text
+      xml_document.xpath("//book[id[text()='#{book_id}']]/chapters/chapter").each do |chapter_element|
+        chapter_id = chapter_element.xpath("id")[0].text
+        chapter_title = chapter_element.xpath("title")[0].text
+        chapter_introduction = chapter_element.xpath("introduction")[0].text
+        chapter = Chapter.find(chapter_id)
+
+        if chapter == nil
+          fail "Chapters with id #{chapter_id} is missing"
+        else
+          if chapter_title != chapter.title
+            fail "Chapter title in database doesn't match chapter title in xml for chapter with id #{chapter_id}, XML: #{chapter_title}, Database: #{chapter.title}"
+          end
+          if chapter_introduction != chapter.introduction
+            fail "Chapter introduction in database doesn't match chapter introduction in xml for chapter with id #{chapter_id}, XML: #{chapter_introduction}, Database: #{chapter.introduction}"
+          end
+          if book_id != chapter.book_id.to_s
+            fail "Chapter book_id in database doesn't match chapter book_id in xml for chapter with id #{chapter_id}, XML: #{book_id}, Database: #{chapter.book_id}"
+          end
+        end
+      end
+    end
+
+
+    # Ensure there are not extra chapters
+    chapters_in_xml = xml_document.xpath("//chapter")
+    if chapters_in_database.count != chapters_in_xml.count
+      fail "There number of chapters in the database (#{chapters_in_database.count}) doesn't match the number of chapters in the xml document (#{chapters_in_xml.count})"
+    end
+
+  else
+    fail "no chapters recorded"
+  end
+end
+
+When /^the database will contain identical pages for the chapters as those in "([^"]*)"$/ do |xml_document_file|
+  chapters_in_database = Chapter.all
+  if chapters_in_database.count > 0
+    xml_document = Nokogiri::XML(File.open(Rails.root.join(xml_document_file)).read)
+
+    # Ensure that all chapters in the xml document have been recorded
+    xml_document.xpath("//book").each do |book_element|
+      book_id = book_element.xpath("id").text
+      xml_document.xpath("//book[id[text()='#{book_id}']]/chapters/chapter").each do |chapter_element|
+        chapter_id = chapter_element.xpath("id")[0].text
+        pages = Page.where(:chapter_id => chapter_id)
+        if (pages.count > 0)
+          xml_document.xpath("//chapter[id[text()='#{chapter_id}']]/pages/page").each do |page_element|
+            page_id = page_element.xpath("id")[0].text
+            page_content = page_element.xpath("content")[0].text
+            page_number = page_element.xpath("number")[0].text
+            page = Page.find(page_id)
+
+            if page == nil
+              fail "Page with id #{page_id} is missing"
+            else
+              if page_content != page.content
+                file "Page content in database doesn't match page content in xml for page with id #{page_id}, XML: #{page_content}, Database: #{page.content}"
+              end
+              
+              if page_number != page.number.to_s
+                fail "Page number in database doesn't match page number in xml for page with id #{page_id}, XML: #{page_number}, Database: #{page.number}"
+              end
+            end
+          end
+        else
+          fail "no pages recorded for chapter with id #{chapter_id}"
+        end
+      end
+    end
+
+
+    # Ensure there are not extra pages
+    pages_in_xml = xml_document.xpath("//page")
+    pages_in_database = Page.all
+    if pages_in_database.count != pages_in_xml.count
+      fail "There number of pages in the database (#{pages_in_database.count}) doesn't match the number of pages in the xml document (#{pages_in_xml.count})"
+    end
+
+  else
+    fail "no chapters recorded"
+  end
+end
+
+Given /^I have a fresh set of books$/ do
+  StepHelper.load_fixtures File.join(Rails.root, 'features', 'support', 'fixtures', 'fresh')
+end
+
+Given /^I have a fresh set of books without the one to one record$/ do
+  StepHelper.load_fixtures File.join(Rails.root, 'features', 'support', 'fixtures', 'without_one_to_one')
+end
+
+Given /^I have a fresh set of books without any chapters$/ do
+  StepHelper.load_fixtures File.join(Rails.root, 'features', 'support', 'fixtures', 'without_chapters')
+end

data/features/step_definitions/update_database_with_xml.rb

@@ -0,0 +1,158 @@
+require "active_record/fixtures"
+require_relative "step_helper"
+
+Then /^the books with the same identifying features as those in "([^"]*)" will be updated$/ do |xml_document_file|
+  books_in_database = Book.all
+  xml_document = Nokogiri::XML(File.open(Rails.root.join(xml_document_file)).read)
+
+  # Ensure that all books in the xml document have been updated
+  book_elements = xml_document.xpath("//book")
+  book_elements.each do |book_element|
+    book_id = book_element.xpath("//book/id")[0].text
+    book_name = book_element.xpath("//book/name")[0].text
+    begin
+      book = Book.find(book_id)
+    rescue
+    end
+
+    if book != nil
+      if book_name != book.name
+        fail "Book name in database doesn't match book name in xml for book with id #{book_id}, XML: #{book_name}, Database: #{book.name}"
+      end
+    end
+  end
+
+  # Check the records that don't exist in the XML Document haven't been changed
+  @original_books.each do |original_book|
+    xml_book = xml_document.xpath("//book[id[text()='#{original_book.id}']]")
+    if xml_book.count == 0
+      book_in_database = Book.find(original_book.id)
+      if book_in_database.name != original_book.name
+        fail "Book name in database doesn't match the original book name for book with id #{original_book.id}, Original: #{original_book.name}, Database: #{book_in_database.name}"
+      end
+    end
+  end
+
+  # Ensure there are no extra books
+  if books_in_database.count != @original_books.count
+    fail "There number of books in the database (#{books_in_database.count}) doesn't match the original number of books (#{@original_books.count})"
+  end
+end
+
+Then /^the chapters with the same identifying features as those in "([^"]*)" will be updated$/ do |xml_document_file|
+  chapters_in_database = Chapter.all
+  xml_document = Nokogiri::XML(File.open(Rails.root.join(xml_document_file)).read)
+
+  # Ensure that all chapters in the xml document have been updated
+  xml_document.xpath("//book").each do |book_element|
+    book_id = book_element.xpath("id").text
+    xml_document.xpath("//book[id[text()='#{book_id}']]/chapters/chapter").each do |chapter_element|
+      chapter_id = chapter_element.xpath("id")[0].text
+      chapter_title = chapter_element.xpath("title")[0].text
+      chapter_introduction = chapter_element.xpath("introduction")[0].text
+      begin
+        chapter = Chapter.find(chapter_id)
+      rescue
+      end
+
+      if chapter != nil
+        if chapter_title != chapter.title
+          fail "Chapter title in database doesn't match chapter title in xml for chapter with id #{chapter_id}, XML: #{chapter_title}, Database: #{chapter.title}"
+        end
+        if chapter_introduction != chapter.introduction
+          fail "Chapter introduction in database doesn't match chapter introduction in xml for chapter with id #{chapter_id}, XML: #{chapter_introduction}, Database: #{chapter.introduction}"
+        end
+        if book_id != chapter.book_id.to_s
+          fail "Chapter book_id in database doesn't match chapter book_id in xml for chapter with id #{chapter_id}, XML: #{book_id}, Database: #{chapter.book_id}"
+        end
+      end
+    end
+  end
+
+  # Check the records that don't exist in the XML Document haven't been changed
+  @original_chapters.each do |original_chapter|
+    xml_chapter = xml_document.xpath("//chapter[id[text()='#{original_chapter.id}']]")
+    if xml_chapter.count == 0
+      chapter_in_database = Chapter.find(original_chapter.id)
+      if chapter_in_database.title != original_chapter.title
+        fail "Chapter title in database doesn't match the original chapter title for chapter with id #{original_chapter.id}, Original: #{original_chapter.title}, Database: #{chapter_in_database.title}"
+      end
+      if chapter_in_database.introduction != original_chapter.introduction
+        fail "Chapter introduction in database doesn't match the original chapter introduction for chapter with id #{original_chapter.id}, Original: #{original_chapter.introduction}, Database: #{chapter_in_database.introduction}"
+      end
+      if chapter_in_database.book_id != original_chapter.book_id
+        fail "Chapter book_id in database doesn't match the original chapter book_id for chapter with id #{original_chapter.id}, Original: #{original_chapter.book_id}, Database: #{chapter_in_database.book_id}"
+      end
+    end
+  end
+
+  # Ensure there are no extra chapters
+  if chapters_in_database.count != @original_chapters.count
+    fail "The number of chapters in the database (#{chapters_in_database.count}) doesn't match the original number of chapters (#{@original_chapters.count})"
+  end
+end
+
+Then /^the pages with the same identifying features as those in "([^"]*)" will be updated$/ do |xml_document_file|
+  xml_document = Nokogiri::XML(File.open(Rails.root.join(xml_document_file)).read)
+
+  # Ensure that all chapters in the xml document have been updated
+  xml_document.xpath("//book").each do |book_element|
+    book_id = book_element.xpath("id").text
+    xml_document.xpath("//book[id[text()='#{book_id}']]/chapters/chapter").each do |chapter_element|
+      chapter_id = chapter_element.xpath("id")[0].text
+      begin
+        pages = Page.where(:chapter_id => chapter_id)
+      rescue
+      end
+
+      if pages.count > 0
+        xml_document.xpath("//chapter[id[text()='#{chapter_id}']]/pages/page").each do |page_element|
+          page_id = page_element.xpath("id")[0].text
+          page_content = page_element.xpath("content")[0].text
+          page_number = page_element.xpath("number")[0].text
+          begin
+            page = Page.find(page_id)
+          rescue
+          end
+
+          if page != nil
+            if page_content != page.content
+              file "Page content in database doesn't match page content in xml for page with id #{page_id}, XML: #{page_content}, Database: #{page.content}"
+            end
+
+            if page_number != page.number.to_s
+              fail "Page number in database doesn't match page number in xml for page with id #{page_id}, XML: #{page_number}, Database: #{page.number}"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # Check the records that don't exist in the XML Document haven't been changed
+  @original_pages.each do |original_page|
+    xml_page = xml_document.xpath("//page[id[text()='#{original_page.id}']]")
+    if xml_page.count == 0
+      page_in_database = Page.find(original_page.id)
+      if page_in_database.content != original_page.content
+        fail "Page content in database doesn't match the original page content for page with id #{original_page.id}, Original: #{original_chapter.content}, Database: #{chapter_in_database.content}"
+      end
+      if page_in_database.number != original_page.number
+        fail "Page number in database doesn't match the original page number for page with id #{original_page.id}, Original: #{original_page.number}, Database: #{page_in_database.number}"
+      end
+      if page_in_database.chapter_id != original_page.chapter_id
+        fail "Page chapter_id in database doesn't match the original page chapter_id for page with id #{original_page.id}, Original: #{original_page.chapter_id}, Database: #{page_in_database.chapter_id}"
+      end
+    end
+  end
+
+  # Ensure there are no extra pages
+  pages_in_database = Page.all
+  if pages_in_database.count != @original_pages.count
+    fail "There number of pages in the database (#{pages_in_database.count}) doesn't match the original number of pages (#{@original_pages.count})"
+  end
+end
+Given /^I have no matching books$/ do
+  StepHelper.load_fixtures File.join(Rails.root, 'features', 'support', 'fixtures', 'no_matching_records')
+end
+

data/features/step_definitions/web_steps.rb

@@ -0,0 +1,211 @@
+# TL;DR: YOU SHOULD DELETE THIS FILE
+#
+# This file was generated by Cucumber-Rails and is only here to get you a head start
+# These step definitions are thin wrappers around the Capybara/Webrat API that lets you
+# visit pages, interact with widgets and make assertions about page content.
+#
+# If you use these step definitions as basis for your features you will quickly end up
+# with features that are:
+#
+# * Hard to maintain
+# * Verbose to read
+#
+# A much better approach is to write your own higher level step definitions, following
+# the advice in the following blog posts:
+#
+# * http://benmabey.com/2008/05/19/imperative-vs-declarative-scenarios-in-user-stories.html
+# * http://dannorth.net/2011/01/31/whose-domain-is-it-anyway/
+# * http://elabs.se/blog/15-you-re-cuking-it-wrong
+#
+
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "selectors"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(*selector_for(locator)) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+# Single-line step scoper
+When /^(.*) within (.*[^:])$/ do |step, parent|
+  with_scope(parent) { When step }
+end
+
+# Multi-line step scoper
+When /^(.*) within (.*[^:]):$/ do |step, parent, table_or_string|
+  with_scope(parent) { When "#{step}:", table_or_string }
+end
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^"]*)"$/ do |button|
+  click_button(button)
+end
+
+When /^(?:|I )follow "([^"]*)"$/ do |link|
+  click_link(link)
+end
+
+When /^(?:|I )fill in "([^"]*)" with "([^"]*)"$/ do |field, value|
+  fill_in(field, :with => value)
+end
+
+When /^(?:|I )fill in "([^"]*)" for "([^"]*)"$/ do |value, field|
+  fill_in(field, :with => value)
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select og option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following:$/ do |fields|
+  fields.rows_hash.each do |name, value|
+    When %{I fill in "#{name}" with "#{value}"}
+  end
+end
+
+When /^(?:|I )select "([^"]*)" from "([^"]*)"$/ do |value, field|
+  select(value, :from => field)
+end
+
+When /^(?:|I )check "([^"]*)"$/ do |field|
+  check(field)
+end
+
+When /^(?:|I )uncheck "([^"]*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^(?:|I )choose "([^"]*)"$/ do |field|
+  choose(field)
+end
+
+When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"$/ do |path, field|
+  attach_file(field, File.expand_path(path))
+end
+
+Then /^(?:|I )should see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_content(text)
+  else
+    assert page.has_content?(text)
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_xpath('//*', :text => regexp)
+  else
+    assert page.has_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^(?:|I )should not see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_no_content(text)
+  else
+    assert page.has_no_content?(text)
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_no_xpath('//*', :text => regexp)
+  else
+    assert page.has_no_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^the "([^"]*)" field(?: within (.*))? should contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should
+      field_value.should =~ /#{value}/
+    else
+      assert_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field(?: within (.*))? should not contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should_not
+      field_value.should_not =~ /#{value}/
+    else
+      assert_no_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within (.*))? should be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_true
+    else
+      assert field_checked
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within (.*))? should not be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_false
+    else
+      assert !field_checked
+    end
+  end
+end
+ 
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  if current_path.respond_to? :should
+    current_path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), current_path
+  end
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  actual_params = query ? CGI.parse(query) : {}
+  expected_params = {}
+  expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')} 
+  
+  if actual_params.respond_to? :should
+    actual_params.should == expected_params
+  else
+    assert_equal expected_params, actual_params
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end